git.sesse.net Git - ffmpeg/blob - libavcodec/nvdec.c

   1 /*
   2  * HW decode acceleration through NVDEC
   3  *
   4  * Copyright (c) 2016 Anton Khirnov
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include "libavutil/common.h"
  26 #include "libavutil/error.h"
  27 #include "libavutil/hwcontext.h"
  28 #include "libavutil/hwcontext_cuda_internal.h"
  29 #include "libavutil/pixdesc.h"
  30 #include "libavutil/pixfmt.h"
  31
  32 #include "avcodec.h"
  33 #include "decode.h"
  34 #include "nvdec.h"
  35 #include "internal.h"
  36
  37 typedef struct NVDECDecoder {
  38     CUvideodecoder decoder;
  39
  40     AVBufferRef *hw_device_ref;
  41     CUcontext    cuda_ctx;
  42
  43     CudaFunctions *cudl;
  44     CuvidFunctions *cvdl;
  45 } NVDECDecoder;
  46
  47 typedef struct NVDECFramePool {
  48     unsigned int dpb_size;
  49     unsigned int nb_allocated;
  50 } NVDECFramePool;
  51
  52 static int map_avcodec_id(enum AVCodecID id)
  53 {
  54     switch (id) {
  55     case AV_CODEC_ID_H264:       return cudaVideoCodec_H264;
  56     case AV_CODEC_ID_HEVC:       return cudaVideoCodec_HEVC;
  57     case AV_CODEC_ID_MJPEG:      return cudaVideoCodec_JPEG;
  58     case AV_CODEC_ID_MPEG1VIDEO: return cudaVideoCodec_MPEG1;
  59     case AV_CODEC_ID_MPEG2VIDEO: return cudaVideoCodec_MPEG2;
  60     case AV_CODEC_ID_MPEG4:      return cudaVideoCodec_MPEG4;
  61     case AV_CODEC_ID_VC1:        return cudaVideoCodec_VC1;
  62     case AV_CODEC_ID_VP8:        return cudaVideoCodec_VP8;
  63     case AV_CODEC_ID_VP9:        return cudaVideoCodec_VP9;
  64     case AV_CODEC_ID_WMV3:       return cudaVideoCodec_VC1;
  65     }
  66     return -1;
  67 }
  68
  69 static int map_chroma_format(enum AVPixelFormat pix_fmt)
  70 {
  71     int shift_h = 0, shift_v = 0;
  72
  73     av_pix_fmt_get_chroma_sub_sample(pix_fmt, &shift_h, &shift_v);
  74
  75     if (shift_h == 1 && shift_v == 1)
  76         return cudaVideoChromaFormat_420;
  77     else if (shift_h == 1 && shift_v == 0)
  78         return cudaVideoChromaFormat_422;
  79     else if (shift_h == 0 && shift_v == 0)
  80         return cudaVideoChromaFormat_444;
  81
  82     return -1;
  83 }
  84
  85 static int nvdec_test_capabilities(NVDECDecoder *decoder,
  86                                    CUVIDDECODECREATEINFO *params, void *logctx)
  87 {
  88     CUresult err;
  89     CUVIDDECODECAPS caps = { 0 };
  90
  91     caps.eCodecType      = params->CodecType;
  92     caps.eChromaFormat   = params->ChromaFormat;
  93     caps.nBitDepthMinus8 = params->bitDepthMinus8;
  94
  95     if (!decoder->cvdl->cuvidGetDecoderCaps) {
  96         av_log(logctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
  97         av_log(logctx, AV_LOG_WARNING, "The minimum required version is "
  98 #if defined(_WIN32) || defined(__CYGWIN__)
  99             "378.66"
 100 #else
 101             "378.13"
 102 #endif
 103             ". Continuing blind.\n");
 104         return 0;
 105     }
 106
 107     err = decoder->cvdl->cuvidGetDecoderCaps(&caps);
 108     if (err != CUDA_SUCCESS) {
 109         av_log(logctx, AV_LOG_ERROR, "Failed querying decoder capabilities\n");
 110         return AVERROR_UNKNOWN;
 111     }
 112
 113     av_log(logctx, AV_LOG_VERBOSE, "NVDEC capabilities:\n");
 114     av_log(logctx, AV_LOG_VERBOSE, "format supported: %s, max_mb_count: %d\n",
 115            caps.bIsSupported ? "yes" : "no", caps.nMaxMBCount);
 116     av_log(logctx, AV_LOG_VERBOSE, "min_width: %d, max_width: %d\n",
 117            caps.nMinWidth, caps.nMaxWidth);
 118     av_log(logctx, AV_LOG_VERBOSE, "min_height: %d, max_height: %d\n",
 119            caps.nMinHeight, caps.nMaxHeight);
 120
 121     if (!caps.bIsSupported) {
 122         av_log(logctx, AV_LOG_ERROR, "Hardware is lacking required capabilities\n");
 123         return AVERROR(EINVAL);
 124     }
 125
 126     if (params->ulWidth > caps.nMaxWidth || params->ulWidth < caps.nMinWidth) {
 127         av_log(logctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
 128                (int)params->ulWidth, caps.nMinWidth, caps.nMaxWidth);
 129         return AVERROR(EINVAL);
 130     }
 131
 132     if (params->ulHeight > caps.nMaxHeight || params->ulHeight < caps.nMinHeight) {
 133         av_log(logctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
 134                (int)params->ulHeight, caps.nMinHeight, caps.nMaxHeight);
 135         return AVERROR(EINVAL);
 136     }
 137
 138     if ((params->ulWidth * params->ulHeight) / 256 > caps.nMaxMBCount) {
 139         av_log(logctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",
 140                (int)(params->ulWidth * params->ulHeight) / 256, caps.nMaxMBCount);
 141         return AVERROR(EINVAL);
 142     }
 143
 144     return 0;
 145 }
 146
 147 static void nvdec_decoder_free(void *opaque, uint8_t *data)
 148 {
 149     NVDECDecoder *decoder = (NVDECDecoder*)data;
 150
 151     if (decoder->decoder)
 152         decoder->cvdl->cuvidDestroyDecoder(decoder->decoder);
 153
 154     av_buffer_unref(&decoder->hw_device_ref);
 155
 156     cuvid_free_functions(&decoder->cvdl);
 157
 158     av_freep(&decoder);
 159 }
 160
 161 static int nvdec_decoder_create(AVBufferRef **out, AVBufferRef *hw_device_ref,
 162                                 CUVIDDECODECREATEINFO *params, void *logctx)
 163 {
 164     AVHWDeviceContext  *hw_device_ctx = (AVHWDeviceContext*)hw_device_ref->data;
 165     AVCUDADeviceContext *device_hwctx = hw_device_ctx->hwctx;
 166
 167     AVBufferRef *decoder_ref;
 168     NVDECDecoder *decoder;
 169
 170     CUcontext dummy;
 171     CUresult err;
 172     int ret;
 173
 174     decoder = av_mallocz(sizeof(*decoder));
 175     if (!decoder)
 176         return AVERROR(ENOMEM);
 177
 178     decoder_ref = av_buffer_create((uint8_t*)decoder, sizeof(*decoder),
 179                                    nvdec_decoder_free, NULL, AV_BUFFER_FLAG_READONLY);
 180     if (!decoder_ref) {
 181         av_freep(&decoder);
 182         return AVERROR(ENOMEM);
 183     }
 184
 185     decoder->hw_device_ref = av_buffer_ref(hw_device_ref);
 186     if (!decoder->hw_device_ref) {
 187         ret = AVERROR(ENOMEM);
 188         goto fail;
 189     }
 190     decoder->cuda_ctx = device_hwctx->cuda_ctx;
 191     decoder->cudl = device_hwctx->internal->cuda_dl;
 192
 193     ret = cuvid_load_functions(&decoder->cvdl, logctx);
 194     if (ret < 0) {
 195         av_log(logctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
 196         goto fail;
 197     }
 198
 199     err = decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx);
 200     if (err != CUDA_SUCCESS) {
 201         ret = AVERROR_UNKNOWN;
 202         goto fail;
 203     }
 204
 205     ret = nvdec_test_capabilities(decoder, params, logctx);
 206     if (ret < 0) {
 207         decoder->cudl->cuCtxPopCurrent(&dummy);
 208         goto fail;
 209     }
 210
 211     err = decoder->cvdl->cuvidCreateDecoder(&decoder->decoder, params);
 212
 213     decoder->cudl->cuCtxPopCurrent(&dummy);
 214
 215     if (err != CUDA_SUCCESS) {
 216         av_log(logctx, AV_LOG_ERROR, "Error creating a NVDEC decoder: %d\n", err);
 217         ret = AVERROR_UNKNOWN;
 218         goto fail;
 219     }
 220
 221     *out = decoder_ref;
 222
 223     return 0;
 224 fail:
 225     av_buffer_unref(&decoder_ref);
 226     return ret;
 227 }
 228
 229 static AVBufferRef *nvdec_decoder_frame_alloc(void *opaque, int size)
 230 {
 231     NVDECFramePool *pool = opaque;
 232     AVBufferRef *ret;
 233
 234     if (pool->nb_allocated >= pool->dpb_size)
 235         return NULL;
 236
 237     ret = av_buffer_alloc(sizeof(unsigned int));
 238     if (!ret)
 239         return NULL;
 240
 241     *(unsigned int*)ret->data = pool->nb_allocated++;
 242
 243     return ret;
 244 }
 245
 246 int ff_nvdec_decode_uninit(AVCodecContext *avctx)
 247 {
 248     NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
 249
 250     av_freep(&ctx->bitstream);
 251     ctx->bitstream_len       = 0;
 252     ctx->bitstream_allocated = 0;
 253
 254     av_freep(&ctx->slice_offsets);
 255     ctx->nb_slices               = 0;
 256     ctx->slice_offsets_allocated = 0;
 257
 258     av_buffer_unref(&ctx->decoder_ref);
 259     av_buffer_pool_uninit(&ctx->decoder_pool);
 260
 261     return 0;
 262 }
 263
 264 int ff_nvdec_decode_init(AVCodecContext *avctx)
 265 {
 266     NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
 267
 268     NVDECFramePool      *pool;
 269     AVHWFramesContext   *frames_ctx;
 270     const AVPixFmtDescriptor *sw_desc;
 271
 272     CUVIDDECODECREATEINFO params = { 0 };
 273
 274     int cuvid_codec_type, cuvid_chroma_format;
 275     int ret = 0;
 276
 277     sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
 278     if (!sw_desc)
 279         return AVERROR_BUG;
 280
 281     cuvid_codec_type = map_avcodec_id(avctx->codec_id);
 282     if (cuvid_codec_type < 0) {
 283         av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");
 284         return AVERROR_BUG;
 285     }
 286
 287     cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);
 288     if (cuvid_chroma_format < 0) {
 289         av_log(avctx, AV_LOG_ERROR, "Unsupported chroma format\n");
 290         return AVERROR(ENOSYS);
 291     }
 292
 293     if (!avctx->hw_frames_ctx) {
 294         ret = ff_decode_get_hw_frames_ctx(avctx, AV_HWDEVICE_TYPE_CUDA);
 295         if (ret < 0)
 296             return ret;
 297     }
 298
 299     frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
 300
 301     params.ulWidth             = avctx->coded_width;
 302     params.ulHeight            = avctx->coded_height;
 303     params.ulTargetWidth       = avctx->coded_width;
 304     params.ulTargetHeight      = avctx->coded_height;
 305     params.bitDepthMinus8      = sw_desc->comp[0].depth - 8;
 306     params.OutputFormat        = params.bitDepthMinus8 ?
 307                                  cudaVideoSurfaceFormat_P016 : cudaVideoSurfaceFormat_NV12;
 308     params.CodecType           = cuvid_codec_type;
 309     params.ChromaFormat        = cuvid_chroma_format;
 310     params.ulNumDecodeSurfaces = frames_ctx->initial_pool_size;
 311     params.ulNumOutputSurfaces = 1;
 312
 313     ret = nvdec_decoder_create(&ctx->decoder_ref, frames_ctx->device_ref, &params, avctx);
 314     if (ret < 0) {
 315         if (params.ulNumDecodeSurfaces > 32) {
 316             av_log(avctx, AV_LOG_WARNING, "Using more than 32 (%d) decode surfaces might cause nvdec to fail.\n",
 317                    (int)params.ulNumDecodeSurfaces);
 318             av_log(avctx, AV_LOG_WARNING, "Try lowering the amount of threads. Using %d right now.\n",
 319                    avctx->thread_count);
 320         }
 321         return ret;
 322     }
 323
 324     pool = av_mallocz(sizeof(*pool));
 325     if (!pool) {
 326         ret = AVERROR(ENOMEM);
 327         goto fail;
 328     }
 329     pool->dpb_size = frames_ctx->initial_pool_size;
 330
 331     ctx->decoder_pool = av_buffer_pool_init2(sizeof(int), pool,
 332                                              nvdec_decoder_frame_alloc, av_free);
 333     if (!ctx->decoder_pool) {
 334         ret = AVERROR(ENOMEM);
 335         goto fail;
 336     }
 337
 338     return 0;
 339 fail:
 340     ff_nvdec_decode_uninit(avctx);
 341     return ret;
 342 }
 343
 344 static void nvdec_fdd_priv_free(void *priv)
 345 {
 346     NVDECFrame *cf = priv;
 347
 348     if (!cf)
 349         return;
 350
 351     av_buffer_unref(&cf->idx_ref);
 352     av_buffer_unref(&cf->decoder_ref);
 353
 354     av_freep(&priv);
 355 }
 356
 357 static int nvdec_retrieve_data(void *logctx, AVFrame *frame)
 358 {
 359     FrameDecodeData  *fdd = (FrameDecodeData*)frame->private_ref->data;
 360     NVDECFrame        *cf = (NVDECFrame*)fdd->hwaccel_priv;
 361     NVDECDecoder *decoder = (NVDECDecoder*)cf->decoder_ref->data;
 362
 363     CUVIDPROCPARAMS vpp = { .progressive_frame = 1 };
 364
 365     CUresult err;
 366     CUcontext dummy;
 367     CUdeviceptr devptr;
 368
 369     unsigned int pitch, i;
 370     unsigned int offset = 0;
 371     int ret = 0;
 372
 373     err = decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx);
 374     if (err != CUDA_SUCCESS)
 375         return AVERROR_UNKNOWN;
 376
 377     err = decoder->cvdl->cuvidMapVideoFrame(decoder->decoder, cf->idx, &devptr,
 378                                             &pitch, &vpp);
 379     if (err != CUDA_SUCCESS) {
 380         av_log(logctx, AV_LOG_ERROR, "Error mapping a picture with CUVID: %d\n",
 381                err);
 382         ret = AVERROR_UNKNOWN;
 383         goto finish;
 384     }
 385
 386     for (i = 0; frame->data[i]; i++) {
 387         CUDA_MEMCPY2D cpy = {
 388             .srcMemoryType = CU_MEMORYTYPE_DEVICE,
 389             .dstMemoryType = CU_MEMORYTYPE_DEVICE,
 390             .srcDevice     = devptr,
 391             .dstDevice     = (CUdeviceptr)frame->data[i],
 392             .srcPitch      = pitch,
 393             .dstPitch      = frame->linesize[i],
 394             .srcY          = offset,
 395             .WidthInBytes  = FFMIN(pitch, frame->linesize[i]),
 396             .Height        = frame->height >> (i ? 1 : 0),
 397         };
 398
 399         err = decoder->cudl->cuMemcpy2D(&cpy);
 400         if (err != CUDA_SUCCESS) {
 401             av_log(logctx, AV_LOG_ERROR, "Error copying decoded frame: %d\n",
 402                    err);
 403             ret = AVERROR_UNKNOWN;
 404             goto copy_fail;
 405         }
 406
 407         offset += cpy.Height;
 408     }
 409
 410 copy_fail:
 411     decoder->cvdl->cuvidUnmapVideoFrame(decoder->decoder, devptr);
 412
 413 finish:
 414     decoder->cudl->cuCtxPopCurrent(&dummy);
 415     return ret;
 416 }
 417
 418 int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
 419 {
 420     NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
 421     FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
 422     NVDECFrame *cf = NULL;
 423     int ret;
 424
 425     ctx->bitstream_len = 0;
 426     ctx->nb_slices     = 0;
 427
 428     if (fdd->hwaccel_priv)
 429         return 0;
 430
 431     cf = av_mallocz(sizeof(*cf));
 432     if (!cf)
 433         return AVERROR(ENOMEM);
 434
 435     cf->decoder_ref = av_buffer_ref(ctx->decoder_ref);
 436     if (!cf->decoder_ref) {
 437         ret = AVERROR(ENOMEM);
 438         goto fail;
 439     }
 440
 441     cf->idx_ref = av_buffer_pool_get(ctx->decoder_pool);
 442     if (!cf->idx_ref) {
 443         av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
 444         ret = AVERROR(ENOMEM);
 445         goto fail;
 446     }
 447     cf->idx = *(unsigned int*)cf->idx_ref->data;
 448
 449     fdd->hwaccel_priv      = cf;
 450     fdd->hwaccel_priv_free = nvdec_fdd_priv_free;
 451     fdd->post_process      = nvdec_retrieve_data;
 452
 453     return 0;
 454 fail:
 455     nvdec_fdd_priv_free(cf);
 456     return ret;
 457
 458 }
 459
 460 int ff_nvdec_end_frame(AVCodecContext *avctx)
 461 {
 462     NVDECContext     *ctx = avctx->internal->hwaccel_priv_data;
 463     NVDECDecoder *decoder = (NVDECDecoder*)ctx->decoder_ref->data;
 464     CUVIDPICPARAMS    *pp = &ctx->pic_params;
 465
 466     CUresult err;
 467     CUcontext dummy;
 468
 469     int ret = 0;
 470
 471     pp->nBitstreamDataLen = ctx->bitstream_len;
 472     pp->pBitstreamData    = ctx->bitstream;
 473     pp->nNumSlices        = ctx->nb_slices;
 474     pp->pSliceDataOffsets = ctx->slice_offsets;
 475
 476     err = decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx);
 477     if (err != CUDA_SUCCESS)
 478         return AVERROR_UNKNOWN;
 479
 480     err = decoder->cvdl->cuvidDecodePicture(decoder->decoder, &ctx->pic_params);
 481     if (err != CUDA_SUCCESS) {
 482         av_log(avctx, AV_LOG_ERROR, "Error decoding a picture with NVDEC: %d\n",
 483                err);
 484         ret = AVERROR_UNKNOWN;
 485         goto finish;
 486     }
 487
 488 finish:
 489     decoder->cudl->cuCtxPopCurrent(&dummy);
 490
 491     return ret;
 492 }
 493
 494 int ff_nvdec_simple_end_frame(AVCodecContext *avctx)
 495 {
 496     NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
 497     int ret = ff_nvdec_end_frame(avctx);
 498     ctx->bitstream = NULL;
 499     return ret;
 500 }
 501
 502 int ff_nvdec_simple_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
 503                                  uint32_t size)
 504 {
 505     NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
 506     void *tmp;
 507
 508     tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
 509                           (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));
 510     if (!tmp)
 511         return AVERROR(ENOMEM);
 512     ctx->slice_offsets = tmp;
 513
 514     if (!ctx->bitstream)
 515         ctx->bitstream = (uint8_t*)buffer;
 516
 517     ctx->slice_offsets[ctx->nb_slices] = buffer - ctx->bitstream;
 518     ctx->bitstream_len += size;
 519     ctx->nb_slices++;
 520
 521     return 0;
 522 }
 523
 524 int ff_nvdec_frame_params(AVCodecContext *avctx,
 525                           AVBufferRef *hw_frames_ctx,
 526                           int dpb_size)
 527 {
 528     AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ctx->data;
 529     const AVPixFmtDescriptor *sw_desc;
 530     int cuvid_codec_type, cuvid_chroma_format;
 531
 532     sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
 533     if (!sw_desc)
 534         return AVERROR_BUG;
 535
 536     cuvid_codec_type = map_avcodec_id(avctx->codec_id);
 537     if (cuvid_codec_type < 0) {
 538         av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");
 539         return AVERROR_BUG;
 540     }
 541
 542     cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);
 543     if (cuvid_chroma_format < 0) {
 544         av_log(avctx, AV_LOG_VERBOSE, "Unsupported chroma format\n");
 545         return AVERROR(EINVAL);
 546     }
 547
 548     frames_ctx->format            = AV_PIX_FMT_CUDA;
 549     frames_ctx->width             = (avctx->coded_width + 1) & ~1;
 550     frames_ctx->height            = (avctx->coded_height + 1) & ~1;
 551     frames_ctx->initial_pool_size = dpb_size;
 552
 553     switch (sw_desc->comp[0].depth) {
 554     case 8:
 555         frames_ctx->sw_format = AV_PIX_FMT_NV12;
 556         break;
 557     case 10:
 558         frames_ctx->sw_format = AV_PIX_FMT_P010;
 559         break;
 560     case 12:
 561         frames_ctx->sw_format = AV_PIX_FMT_P016;
 562         break;
 563     default:
 564         return AVERROR(EINVAL);
 565     }
 566
 567     return 0;
 568 }
 569
 570 int ff_nvdec_get_ref_idx(AVFrame *frame)
 571 {
 572     FrameDecodeData *fdd;
 573     NVDECFrame *cf;
 574
 575     if (!frame || !frame->private_ref)
 576         return -1;
 577
 578     fdd = (FrameDecodeData*)frame->private_ref->data;
 579     cf  = (NVDECFrame*)fdd->hwaccel_priv;
 580     if (!cf)
 581         return -1;
 582
 583     return cf->idx;
 584 }