FFmpeg: libavcodec/nvdec.c Source File

FFmpeg

[フレーム]

libavcodec

nvdec.c

Go to the documentation of this file.

1 /*

2 * HW decode acceleration through NVDEC

3 *

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 */

23 #include "config.h"

24 #include "config_components.h"

26 #include "libavutil/common.h"

27 #include "libavutil/error.h"

28 #include "libavutil/hwcontext.h"

29 #include "libavutil/hwcontext_cuda_internal.h"

30 #include "libavutil/cuda_check.h"

31 #include "libavutil/mem.h"

32 #include "libavutil/pixdesc.h"

33 #include "libavutil/pixfmt.h"

35 #include "avcodec.h"

36 #include "decode.h"

37 #include "nvdec.h"

38 #include "internal.h"

39 #include "refstruct.h"

41 #if !NVDECAPI_CHECK_VERSION(9, 0)

42 #define cudaVideoSurfaceFormat_YUV444 2

43 #define cudaVideoSurfaceFormat_YUV444_16Bit 3

44 #endif

46 typedef struct NVDECDecoder {

47 CUvideodecoder decoder;

49 AVBufferRef *hw_device_ref;

50 AVBufferRef *real_hw_frames_ref;

51 CUcontext cuda_ctx;

52 CUstream stream;

54 CudaFunctions *cudl;

55 CuvidFunctions *cvdl;

57 int unsafe_output;

58 } NVDECDecoder;

60 typedef struct NVDECFramePool {

61 unsigned int dpb_size;

62 unsigned int nb_allocated;

63 } NVDECFramePool;

65 #define CHECK_CU(x) FF_CUDA_CHECK_DL(logctx, decoder->cudl, x)

67 static int map_avcodec_id(enum AVCodecID id)

68 {

69 switch (id) {

70 #if CONFIG_AV1_NVDEC_HWACCEL

71 case AV_CODEC_ID_AV1: return cudaVideoCodec_AV1;

72 #endif

73 case AV_CODEC_ID_H264: return cudaVideoCodec_H264;

74 case AV_CODEC_ID_HEVC: return cudaVideoCodec_HEVC;

75 case AV_CODEC_ID_MJPEG: return cudaVideoCodec_JPEG;

76 case AV_CODEC_ID_MPEG1VIDEO: return cudaVideoCodec_MPEG1;

77 case AV_CODEC_ID_MPEG2VIDEO: return cudaVideoCodec_MPEG2;

78 case AV_CODEC_ID_MPEG4: return cudaVideoCodec_MPEG4;

79 case AV_CODEC_ID_VC1: return cudaVideoCodec_VC1;

80 case AV_CODEC_ID_VP8: return cudaVideoCodec_VP8;

81 case AV_CODEC_ID_VP9: return cudaVideoCodec_VP9;

82 case AV_CODEC_ID_WMV3: return cudaVideoCodec_VC1;

83 }

84 return -1;

85 }

87 static int map_chroma_format(enum AVPixelFormat pix_fmt)

88 {

89 int shift_h = 0, shift_v = 0;

91 if (av_pix_fmt_count_planes(pix_fmt) == 1)

92 return cudaVideoChromaFormat_Monochrome;

94 av_pix_fmt_get_chroma_sub_sample(pix_fmt, &shift_h, &shift_v);

96 if (shift_h == 1 && shift_v == 1)

97 return cudaVideoChromaFormat_420;

98 else if (shift_h == 1 && shift_v == 0)

99 return cudaVideoChromaFormat_422;

100 else if (shift_h == 0 && shift_v == 0)

101 return cudaVideoChromaFormat_444;

102

103 return -1;

104 }

105

106 static int nvdec_test_capabilities(NVDECDecoder *decoder,

107 CUVIDDECODECREATEINFO *params, void *logctx)

108 {

109 int ret;

110 CUVIDDECODECAPS caps = { 0 };

111

112 caps.eCodecType = params->CodecType;

113 caps.eChromaFormat = params->ChromaFormat;

114 caps.nBitDepthMinus8 = params->bitDepthMinus8;

115

116 if (!decoder->cvdl->cuvidGetDecoderCaps) {

117 av_log(logctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");

118 av_log(logctx, AV_LOG_WARNING, "The minimum required version is "

119 #if defined(_WIN32) || defined(__CYGWIN__)

120 "378.66"

121 #else

122 "378.13"

123 #endif

124 ". Continuing blind.\n");

125 return 0;

126 }

127

128 ret = CHECK_CU(decoder->cvdl->cuvidGetDecoderCaps(&caps));

129 if (ret < 0)

130 return ret;

131

132 av_log(logctx, AV_LOG_VERBOSE, "NVDEC capabilities:\n");

133 av_log(logctx, AV_LOG_VERBOSE, "format supported: %s, max_mb_count: %d\n",

134 caps.bIsSupported ? "yes" : "no", caps.nMaxMBCount);

135 av_log(logctx, AV_LOG_VERBOSE, "min_width: %d, max_width: %d\n",

136 caps.nMinWidth, caps.nMaxWidth);

137 av_log(logctx, AV_LOG_VERBOSE, "min_height: %d, max_height: %d\n",

138 caps.nMinHeight, caps.nMaxHeight);

139

140 if (!caps.bIsSupported) {

141 av_log(logctx, AV_LOG_ERROR, "Hardware is lacking required capabilities\n");

142 return AVERROR(EINVAL);

143 }

144

145 if (params->ulWidth > caps.nMaxWidth || params->ulWidth < caps.nMinWidth) {

146 av_log(logctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",

147 (int)params->ulWidth, caps.nMinWidth, caps.nMaxWidth);

148 return AVERROR(EINVAL);

149 }

150

151 if (params->ulHeight > caps.nMaxHeight || params->ulHeight < caps.nMinHeight) {

152 av_log(logctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",

153 (int)params->ulHeight, caps.nMinHeight, caps.nMaxHeight);

154 return AVERROR(EINVAL);

155 }

156

157 if ((params->ulWidth * params->ulHeight) / 256 > caps.nMaxMBCount) {

158 av_log(logctx, AV_LOG_ERROR, "Video macroblock count %d exceeds maximum of %d\n",

159 (int)(params->ulWidth * params->ulHeight) / 256, caps.nMaxMBCount);

160 return AVERROR(EINVAL);

161 }

162

163 return 0;

164 }

165

166 static void nvdec_decoder_free(FFRefStructOpaque unused, void *obj)

167 {

168 NVDECDecoder *decoder = obj;

169

170 if (decoder->decoder) {

171 void *logctx = decoder->hw_device_ref->data;

172 CUcontext dummy;

173 CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));

174 CHECK_CU(decoder->cvdl->cuvidDestroyDecoder(decoder->decoder));

175 CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));

176 }

177

178 av_buffer_unref(&decoder->real_hw_frames_ref);

179 av_buffer_unref(&decoder->hw_device_ref);

180

181 cuvid_free_functions(&decoder->cvdl);

182 }

183

184 static int nvdec_decoder_create(NVDECDecoder **out, AVBufferRef *hw_device_ref,

185 CUVIDDECODECREATEINFO *params, void *logctx)

186 {

187 AVHWDeviceContext *hw_device_ctx = (AVHWDeviceContext*)hw_device_ref->data;

188 AVCUDADeviceContext *device_hwctx = hw_device_ctx->hwctx;

189

190 NVDECDecoder *decoder;

191

192 CUcontext dummy;

193 int ret;

194

195 decoder = ff_refstruct_alloc_ext(sizeof(*decoder), 0,

196 NULL, nvdec_decoder_free);

197 if (!decoder)

198 return AVERROR(ENOMEM);

199

200 decoder->hw_device_ref = av_buffer_ref(hw_device_ref);

201 if (!decoder->hw_device_ref) {

202 ret = AVERROR(ENOMEM);

203 goto fail;

204 }

205 decoder->cuda_ctx = device_hwctx->cuda_ctx;

206 decoder->cudl = device_hwctx->internal->cuda_dl;

207 decoder->stream = device_hwctx->stream;

208

209 ret = cuvid_load_functions(&decoder->cvdl, logctx);

210 if (ret < 0) {

211 av_log(logctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");

212 goto fail;

213 }

214

215 ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));

216 if (ret < 0)

217 goto fail;

218

219 ret = nvdec_test_capabilities(decoder, params, logctx);

220 if (ret < 0) {

221 CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));

222 goto fail;

223 }

224

225 ret = CHECK_CU(decoder->cvdl->cuvidCreateDecoder(&decoder->decoder, params));

226

227 CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));

228

229 if (ret < 0) {

230 goto fail;

231 }

232

233 *out = decoder;

234

235 return 0;

236 fail:

237 ff_refstruct_unref(&decoder);

238 return ret;

239 }

240

241 static int nvdec_decoder_frame_init(FFRefStructOpaque opaque, void *obj)

242 {

243 NVDECFramePool *pool = opaque.nc;

244 unsigned int *intp = obj;

245

246 if (pool->nb_allocated >= pool->dpb_size)

247 return AVERROR(ENOMEM);

248

249 *intp = pool->nb_allocated++;

250

251 return 0;

252 }

253

254 static void nvdec_decoder_frame_pool_free(FFRefStructOpaque opaque)

255 {

256 av_free(opaque.nc);

257 }

258

259 int ff_nvdec_decode_uninit(AVCodecContext *avctx)

260 {

261 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

262

263 av_freep(&ctx->bitstream_internal);

264 ctx->bitstream = NULL;

265 ctx->bitstream_len = 0;

266 ctx->bitstream_allocated = 0;

267

268 av_freep(&ctx->slice_offsets);

269 ctx->nb_slices = 0;

270 ctx->slice_offsets_allocated = 0;

271

272 ff_refstruct_unref(&ctx->decoder);

273 ff_refstruct_pool_uninit(&ctx->decoder_pool);

274

275 return 0;

276 }

277

278 static void nvdec_free_dummy(struct AVHWFramesContext *ctx)

279 {

280 av_buffer_pool_uninit(&ctx->pool);

281 }

282

283 static AVBufferRef *nvdec_alloc_dummy(size_t size)

284 {

285 return av_buffer_create(NULL, 0, NULL, NULL, 0);

286 }

287

288 static int nvdec_init_hwframes(AVCodecContext *avctx, AVBufferRef **out_frames_ref, int dummy)

289 {

290 AVHWFramesContext *frames_ctx;

291 int ret;

292

293 ret = avcodec_get_hw_frames_parameters(avctx,

294 avctx->hw_device_ctx,

295 avctx->hwaccel->pix_fmt,

296 out_frames_ref);

297 if (ret < 0)

298 return ret;

299

300 frames_ctx = (AVHWFramesContext*)(*out_frames_ref)->data;

301

302 if (dummy) {

303 // Copied from ff_decode_get_hw_frames_ctx for compatibility

304 frames_ctx->initial_pool_size += 3;

305

306 frames_ctx->free = nvdec_free_dummy;

307 frames_ctx->pool = av_buffer_pool_init(0, nvdec_alloc_dummy);

308

309 if (!frames_ctx->pool) {

310 av_buffer_unref(out_frames_ref);

311 return AVERROR(ENOMEM);

312 }

313 } else {

314 // This is normally not used to actually allocate frames from

315 frames_ctx->initial_pool_size = 0;

316 }

317

318 ret = av_hwframe_ctx_init(*out_frames_ref);

319 if (ret < 0) {

320 av_buffer_unref(out_frames_ref);

321 return ret;

322 }

323

324 return 0;

325 }

326

327 int ff_nvdec_decode_init(AVCodecContext *avctx)

328 {

329 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

330

331 NVDECDecoder *decoder;

332 AVBufferRef *real_hw_frames_ref;

333 NVDECFramePool *pool;

334 AVHWFramesContext *frames_ctx;

335 const AVPixFmtDescriptor *sw_desc;

336

337 CUVIDDECODECREATEINFO params = { 0 };

338

339 cudaVideoSurfaceFormat output_format;

340 int cuvid_codec_type, cuvid_chroma_format, chroma_444;

341 int ret = 0;

342

343 int unsafe_output = !!(avctx->hwaccel_flags & AV_HWACCEL_FLAG_UNSAFE_OUTPUT);

344

345 sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);

346 if (!sw_desc)

347 return AVERROR_BUG;

348

349 cuvid_codec_type = map_avcodec_id(avctx->codec_id);

350 if (cuvid_codec_type < 0) {

351 av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");

352 return AVERROR_BUG;

353 }

354

355 cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);

356 if (cuvid_chroma_format < 0) {

357 av_log(avctx, AV_LOG_ERROR, "Unsupported chroma format\n");

358 return AVERROR(ENOSYS);

359 }

360 chroma_444 = ctx->supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;

361

362 if (!avctx->hw_frames_ctx) {

363 ret = nvdec_init_hwframes(avctx, &avctx->hw_frames_ctx, 1);

364 if (ret < 0)

365 return ret;

366

367 ret = nvdec_init_hwframes(avctx, &real_hw_frames_ref, 0);

368 if (ret < 0)

369 return ret;

370 } else {

371 real_hw_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);

372 if (!real_hw_frames_ref)

373 return AVERROR(ENOMEM);

374 }

375

376 switch (sw_desc->comp[0].depth) {

377 case 8:

378 output_format = chroma_444 ? cudaVideoSurfaceFormat_YUV444 :

379 cudaVideoSurfaceFormat_NV12;

380 break;

381 case 10:

382 case 12:

383 output_format = chroma_444 ? cudaVideoSurfaceFormat_YUV444_16Bit :

384 cudaVideoSurfaceFormat_P016;

385 break;

386 default:

387 av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth\n");

388 av_buffer_unref(&real_hw_frames_ref);

389 return AVERROR(ENOSYS);

390 }

391

392 frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

393

394 params.ulWidth = avctx->coded_width;

395 params.ulHeight = avctx->coded_height;

396 params.ulTargetWidth = avctx->coded_width;

397 params.ulTargetHeight = avctx->coded_height;

398 params.bitDepthMinus8 = sw_desc->comp[0].depth - 8;

399 params.OutputFormat = output_format;

400 params.CodecType = cuvid_codec_type;

401 params.ChromaFormat = cuvid_chroma_format;

402 params.ulNumDecodeSurfaces = frames_ctx->initial_pool_size;

403 params.ulNumOutputSurfaces = unsafe_output ? frames_ctx->initial_pool_size : 1;

404

405 ret = nvdec_decoder_create(&ctx->decoder, frames_ctx->device_ref, &params, avctx);

406 if (ret < 0) {

407 if (params.ulNumDecodeSurfaces > 32) {

408 av_log(avctx, AV_LOG_WARNING, "Using more than 32 (%d) decode surfaces might cause nvdec to fail.\n",

409 (int)params.ulNumDecodeSurfaces);

410 av_log(avctx, AV_LOG_WARNING, "Try lowering the amount of threads. Using %d right now.\n",

411 avctx->thread_count);

412 }

413 av_buffer_unref(&real_hw_frames_ref);

414 return ret;

415 }

416

417 decoder = ctx->decoder;

418 decoder->unsafe_output = unsafe_output;

419 decoder->real_hw_frames_ref = real_hw_frames_ref;

420 real_hw_frames_ref = NULL;

421

422 pool = av_mallocz(sizeof(*pool));

423 if (!pool) {

424 ret = AVERROR(ENOMEM);

425 goto fail;

426 }

427 pool->dpb_size = frames_ctx->initial_pool_size;

428

429 ctx->decoder_pool = ff_refstruct_pool_alloc_ext(sizeof(unsigned int), 0, pool,

430 nvdec_decoder_frame_init,

431 NULL, NULL, nvdec_decoder_frame_pool_free);

432 if (!ctx->decoder_pool) {

433 ret = AVERROR(ENOMEM);

434 goto fail;

435 }

436

437 return 0;

438 fail:

439 ff_nvdec_decode_uninit(avctx);

440 return ret;

441 }

442

443 static void nvdec_fdd_priv_free(void *priv)

444 {

445 NVDECFrame *cf = priv;

446

447 if (!cf)

448 return;

449

450 ff_refstruct_unref(&cf->idx_ref);

451 ff_refstruct_unref(&cf->ref_idx_ref);

452 ff_refstruct_unref(&cf->decoder);

453

454 av_freep(&priv);

455 }

456

457 static void nvdec_unmap_mapped_frame(void *opaque, uint8_t *data)

458 {

459 NVDECFrame *unmap_data = (NVDECFrame*)data;

460 NVDECDecoder *decoder = unmap_data->decoder;

461 void *logctx = decoder->hw_device_ref->data;

462 CUdeviceptr devptr = (CUdeviceptr)opaque;

463 int ret;

464 CUcontext dummy;

465

466 ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));

467 if (ret < 0)

468 goto finish;

469

470 CHECK_CU(decoder->cvdl->cuvidUnmapVideoFrame(decoder->decoder, devptr));

471

472 CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));

473

474 finish:

475 ff_refstruct_unref(&unmap_data->idx_ref);

476 ff_refstruct_unref(&unmap_data->ref_idx_ref);

477 ff_refstruct_unref(&unmap_data->decoder);

478 av_free(unmap_data);

479 }

480

481 static int nvdec_retrieve_data(void *logctx, AVFrame *frame)

482 {

483 FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;

484 NVDECFrame *cf = (NVDECFrame*)fdd->hwaccel_priv;

485 NVDECDecoder *decoder = cf->decoder;

486

487 AVHWFramesContext *hwctx = (AVHWFramesContext *)frame->hw_frames_ctx->data;

488

489 CUVIDPROCPARAMS vpp = { 0 };

490 NVDECFrame *unmap_data = NULL;

491

492 CUcontext dummy;

493 CUdeviceptr devptr;

494

495 unsigned int pitch, i;

496 unsigned int offset = 0;

497 int shift_h = 0, shift_v = 0;

498 int ret = 0;

499

500 vpp.progressive_frame = 1;

501 vpp.output_stream = decoder->stream;

502

503 ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));

504 if (ret < 0)

505 return ret;

506

507 ret = CHECK_CU(decoder->cvdl->cuvidMapVideoFrame(decoder->decoder,

508 cf->idx, &devptr,

509 &pitch, &vpp));

510 if (ret < 0)

511 goto finish;

512

513 unmap_data = av_mallocz(sizeof(*unmap_data));

514 if (!unmap_data) {

515 ret = AVERROR(ENOMEM);

516 goto copy_fail;

517 }

518

519 frame->buf[1] = av_buffer_create((uint8_t *)unmap_data, sizeof(*unmap_data),

520 nvdec_unmap_mapped_frame, (void*)devptr,

521 AV_BUFFER_FLAG_READONLY);

522 if (!frame->buf[1]) {

523 ret = AVERROR(ENOMEM);

524 goto copy_fail;

525 }

526

527 ret = av_buffer_replace(&frame->hw_frames_ctx, decoder->real_hw_frames_ref);

528 if (ret < 0)

529 goto copy_fail;

530

531 unmap_data->idx = cf->idx;

532 unmap_data->idx_ref = ff_refstruct_ref(cf->idx_ref);

533 unmap_data->decoder = ff_refstruct_ref(cf->decoder);

534

535 av_pix_fmt_get_chroma_sub_sample(hwctx->sw_format, &shift_h, &shift_v);

536 for (i = 0; frame->linesize[i]; i++) {

537 frame->data[i] = (uint8_t*)(devptr + offset);

538 frame->linesize[i] = pitch;

539 offset += pitch * (frame->height >> (i ? shift_v : 0));

540 }

541

542 goto finish;

543

544 copy_fail:

545 if (!frame->buf[1]) {

546 CHECK_CU(decoder->cvdl->cuvidUnmapVideoFrame(decoder->decoder, devptr));

547 av_freep(&unmap_data);

548 } else {

549 av_buffer_unref(&frame->buf[1]);

550 }

551

552 finish:

553 CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));

554

555 if (ret < 0 || decoder->unsafe_output)

556 return ret;

557

558 return av_frame_make_writable(frame);

559 }

560

561 int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)

562 {

563 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

564 FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;

565 NVDECFrame *cf = NULL;

566 int ret;

567

568 ctx->bitstream_len = 0;

569 ctx->nb_slices = 0;

570

571 if (fdd->hwaccel_priv)

572 return 0;

573

574 cf = av_mallocz(sizeof(*cf));

575 if (!cf)

576 return AVERROR(ENOMEM);

577

578 cf->decoder = ff_refstruct_ref(ctx->decoder);

579

580 cf->idx_ref = ff_refstruct_pool_get(ctx->decoder_pool);

581 if (!cf->idx_ref) {

582 av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");

583 ret = AVERROR(ENOMEM);

584 goto fail;

585 }

586 cf->ref_idx = cf->idx = *cf->idx_ref;

587

588 fdd->hwaccel_priv = cf;

589 fdd->hwaccel_priv_free = nvdec_fdd_priv_free;

590 fdd->post_process = nvdec_retrieve_data;

591

592 return 0;

593 fail:

594 nvdec_fdd_priv_free(cf);

595 return ret;

596

597 }

598

599 int ff_nvdec_start_frame_sep_ref(AVCodecContext *avctx, AVFrame *frame, int has_sep_ref)

600 {

601 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

602 FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;

603 NVDECFrame *cf;

604 int ret;

605

606 ret = ff_nvdec_start_frame(avctx, frame);

607 if (ret < 0)

608 return ret;

609

610 cf = fdd->hwaccel_priv;

611

612 if (has_sep_ref) {

613 if (!cf->ref_idx_ref) {

614 cf->ref_idx_ref = ff_refstruct_pool_get(ctx->decoder_pool);

615 if (!cf->ref_idx_ref) {

616 av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");

617 ret = AVERROR(ENOMEM);

618 goto fail;

619 }

620 }

621 cf->ref_idx = *cf->ref_idx_ref;

622 } else {

623 ff_refstruct_unref(&cf->ref_idx_ref);

624 cf->ref_idx = cf->idx;

625 }

626

627 return 0;

628 fail:

629 nvdec_fdd_priv_free(cf);

630 return ret;

631 }

632

633 int ff_nvdec_end_frame(AVCodecContext *avctx)

634 {

635 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

636 NVDECDecoder *decoder = ctx->decoder;

637 void *logctx = avctx;

638 CUVIDPICPARAMS *pp = &ctx->pic_params;

639

640 CUcontext dummy;

641

642 int ret = 0;

643

644 pp->nBitstreamDataLen = ctx->bitstream_len;

645 pp->pBitstreamData = ctx->bitstream;

646 pp->nNumSlices = ctx->nb_slices;

647 pp->pSliceDataOffsets = ctx->slice_offsets;

648

649 ret = CHECK_CU(decoder->cudl->cuCtxPushCurrent(decoder->cuda_ctx));

650 if (ret < 0)

651 return ret;

652

653 ret = CHECK_CU(decoder->cvdl->cuvidDecodePicture(decoder->decoder, &ctx->pic_params));

654 if (ret < 0)

655 goto finish;

656

657 finish:

658 CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));

659

660 return ret;

661 }

662

663 int ff_nvdec_simple_end_frame(AVCodecContext *avctx)

664 {

665 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

666 int ret = ff_nvdec_end_frame(avctx);

667 ctx->bitstream = NULL;

668 ctx->bitstream_len = 0;

669 ctx->nb_slices = 0;

670 return ret;

671 }

672

673 int ff_nvdec_simple_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,

674 uint32_t size)

675 {

676 NVDECContext *ctx = avctx->internal->hwaccel_priv_data;

677 void *tmp;

678

679 tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,

680 (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));

681 if (!tmp)

682 return AVERROR(ENOMEM);

683 ctx->slice_offsets = tmp;

684

685 if (!ctx->bitstream)

686 ctx->bitstream = buffer;

687

688 ctx->slice_offsets[ctx->nb_slices] = buffer - ctx->bitstream;

689 ctx->bitstream_len += size;

690 ctx->nb_slices++;

691

692 return 0;

693 }

694

695 int ff_nvdec_frame_params(AVCodecContext *avctx,

696 AVBufferRef *hw_frames_ctx,

697 int dpb_size,

698 int supports_444)

699 {

700 AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ctx->data;

701 const AVPixFmtDescriptor *sw_desc;

702 int cuvid_codec_type, cuvid_chroma_format, chroma_444;

703

704 sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);

705 if (!sw_desc)

706 return AVERROR_BUG;

707

708 cuvid_codec_type = map_avcodec_id(avctx->codec_id);

709 if (cuvid_codec_type < 0) {

710 av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");

711 return AVERROR_BUG;

712 }

713

714 cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);

715 if (cuvid_chroma_format < 0) {

716 av_log(avctx, AV_LOG_VERBOSE, "Unsupported chroma format\n");

717 return AVERROR(EINVAL);

718 }

719 chroma_444 = supports_444 && cuvid_chroma_format == cudaVideoChromaFormat_444;

720

721 frames_ctx->format = AV_PIX_FMT_CUDA;

722 frames_ctx->width = (avctx->coded_width + 1) & ~1;

723 frames_ctx->height = (avctx->coded_height + 1) & ~1;

724 /*

725 * We add two extra frames to the pool to account for deinterlacing filters

726 * holding onto their frames.

727 */

728 frames_ctx->initial_pool_size = dpb_size + 2;

729

730 switch (sw_desc->comp[0].depth) {

731 case 8:

732 frames_ctx->sw_format = chroma_444 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_NV12;

733 break;

734 case 10:

735 frames_ctx->sw_format = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P010;

736 break;

737 case 12:

738 frames_ctx->sw_format = chroma_444 ? AV_PIX_FMT_YUV444P16 : AV_PIX_FMT_P016;

739 break;

740 default:

741 return AVERROR(EINVAL);

742 }

743

744 return 0;

745 }

746

747 int ff_nvdec_get_ref_idx(AVFrame *frame)

748 {

749 FrameDecodeData *fdd;

750 NVDECFrame *cf;

751

752 if (!frame || !frame->private_ref)

753 return -1;

754

755 fdd = (FrameDecodeData*)frame->private_ref->data;

756 cf = (NVDECFrame*)fdd->hwaccel_priv;

757 if (!cf)

758 return -1;

759

760 return cf->ref_idx;

761 }

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:1437

av_buffer_pool_init

AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))

Allocate and initialize a buffer pool.

Definition: buffer.c:283

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AV_PIX_FMT_CUDA

@ AV_PIX_FMT_CUDA

HW acceleration through CUDA.

Definition: pixfmt.h:260

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

ff_refstruct_ref

void * ff_refstruct_ref(void *obj)

Create a new reference to an object managed via this API, i.e.

Definition: refstruct.c:140

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

map_avcodec_id

static int map_avcodec_id(enum AVCodecID id)

Definition: nvdec.c:67

hwcontext_cuda_internal.h

out

FILE * out

Definition: movenc.c:55

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2965

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

map_chroma_format

static int map_chroma_format(enum AVPixelFormat pix_fmt)

Definition: nvdec.c:87

NVDECFramePool

Definition: nvdec.c:60

AVHWFramesContext::format

enum AVPixelFormat format

The pixel format identifying the underlying HW surface type.

Definition: hwcontext.h:197

NVDECDecoder::stream

CUstream stream

Definition: nvdec.c:52

ff_refstruct_alloc_ext

static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))

A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.

Definition: refstruct.h:94

ff_nvdec_get_ref_idx

int ff_nvdec_get_ref_idx(AVFrame *frame)

Definition: nvdec.c:747

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

FrameDecodeData

This struct stores per-frame lavc-internal data and is attached to it via private_ref.

Definition: decode.h:33

av_hwframe_ctx_init

int av_hwframe_ctx_init(AVBufferRef *ref)

Finalize the context before use.

Definition: hwcontext.c:322

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

av_frame_make_writable

int av_frame_make_writable(AVFrame *frame)

Ensure that the frame data is writable, avoiding data copy if possible.

Definition: frame.c:666

pixdesc.h

internal.h

AVHWFramesContext::free

void(* free)(struct AVHWFramesContext *ctx)

This field may be set by the caller before calling av_hwframe_ctx_init().

Definition: hwcontext.h:158

AVComponentDescriptor::depth

int depth

Number of bits in the component.

Definition: pixdesc.h:57

NVDECDecoder::unsafe_output

int unsafe_output

Definition: nvdec.c:57

data

const char data[16]

Definition: mxf.c:148

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

FrameDecodeData::hwaccel_priv_free

void(* hwaccel_priv_free)(void *priv)

Definition: decode.h:52

FFRefStructOpaque

RefStruct is an API for creating reference-counted objects with minimal overhead.

Definition: refstruct.h:58

NVDECDecoder::decoder

CUvideodecoder decoder

Definition: nvdec.c:47

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

AVHWFramesContext::width

int width

The allocated dimensions of the frames in this pool.

Definition: hwcontext.h:217

nvdec_decoder_frame_init

static int nvdec_decoder_frame_init(FFRefStructOpaque opaque, void *obj)

Definition: nvdec.c:241

NVDECDecoder::cvdl

CuvidFunctions * cvdl

Definition: nvdec.c:55

av_pix_fmt_count_planes

int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3005

decoder

static const chunk_decoder decoder[8]

Definition: dfa.c:331

finish

static void finish(void)

Definition: movenc.c:374

NVDECFrame::idx_ref

unsigned int * idx_ref

RefStruct reference.

Definition: nvdec.h:47

ff_nvdec_start_frame

int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)

Definition: nvdec.c:561

NVDECFrame::ref_idx

unsigned int ref_idx

Definition: nvdec.h:46

fail

#define fail()

Definition: checkasm.h:188

AVCodecContext::thread_count

int thread_count

thread count is used to decide how many independent tasks should be passed to execute()

Definition: avcodec.h:1593

ff_refstruct_pool_uninit

static void ff_refstruct_pool_uninit(FFRefStructPool **poolp)

Mark the pool as being available for freeing.

Definition: refstruct.h:292

dummy

int dummy

Definition: motion.c:66

av_pix_fmt_get_chroma_sub_sample

int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)

Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.

Definition: pixdesc.c:2993

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:639

refstruct.h

AVHWDeviceContext

This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.

Definition: hwcontext.h:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

cudaVideoSurfaceFormat_YUV444

#define cudaVideoSurfaceFormat_YUV444

Definition: nvdec.c:42

AV_HWACCEL_FLAG_UNSAFE_OUTPUT

#define AV_HWACCEL_FLAG_UNSAFE_OUTPUT

Some hardware decoders (namely nvdec) can either output direct decoder surfaces, or make an on-device...

Definition: avcodec.h:2185

AVHWFramesContext::height

int height

Definition: hwcontext.h:217

AVHWFramesContext::pool

AVBufferPool * pool

A pool from which the frames are allocated by av_hwframe_get_buffer().

Definition: hwcontext.h:178

ff_nvdec_start_frame_sep_ref

int ff_nvdec_start_frame_sep_ref(AVCodecContext *avctx, AVFrame *frame, int has_sep_ref)

Definition: nvdec.c:599

av_fast_realloc

void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)

Reallocate the given buffer if it is not large enough, otherwise do nothing.

Definition: mem.c:497

nvdec_decoder_frame_pool_free

static void nvdec_decoder_frame_pool_free(FFRefStructOpaque opaque)

Definition: nvdec.c:254

AV_PIX_FMT_YUV444P16

#define AV_PIX_FMT_YUV444P16

Definition: pixfmt.h:491

AV_BUFFER_FLAG_READONLY

#define AV_BUFFER_FLAG_READONLY

Always treat the buffer as read-only, even when it has only one reference.

Definition: buffer.h:114

nvdec_decoder_free

static void nvdec_decoder_free(FFRefStructOpaque unused, void *obj)

Definition: nvdec.c:166

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

AV_CODEC_ID_VP9

@ AV_CODEC_ID_VP9

Definition: codec_id.h:220

NVDECFrame

Definition: nvdec.h:44

ctx

AVFormatContext * ctx

Definition: movenc.c:49

decode.h

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:461

NVDECDecoder::cudl

CudaFunctions * cudl

Definition: nvdec.c:54

dpb_size

int dpb_size

Definition: h264_levels.c:111

if(ret)

Definition: filter_design.txt:179

AV_CODEC_ID_WMV3

@ AV_CODEC_ID_WMV3

Definition: codec_id.h:123

ff_nvdec_simple_end_frame

int ff_nvdec_simple_end_frame(AVCodecContext *avctx)

Definition: nvdec.c:663

NULL

#define NULL

Definition: coverity.c:32

AVHWFramesContext::sw_format

enum AVPixelFormat sw_format

The pixel format identifying the actual data layout of the hardware frames.

Definition: hwcontext.h:210

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:280

ff_nvdec_decode_init

int ff_nvdec_decode_init(AVCodecContext *avctx)

Definition: nvdec.c:327

AVHWFramesContext::device_ref

AVBufferRef * device_ref

A reference to the parent AVHWDeviceContext.

Definition: hwcontext.h:126

NVDECDecoder::hw_device_ref

AVBufferRef * hw_device_ref

Definition: nvdec.c:49

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:486

av_buffer_pool_uninit

void av_buffer_pool_uninit(AVBufferPool **ppool)

Mark the pool as being available for freeing.

Definition: buffer.c:328

nvdec_decoder_create

static int nvdec_decoder_create(NVDECDecoder **out, AVBufferRef *hw_device_ref, CUVIDDECODECREATEINFO *params, void *logctx)

Definition: nvdec.c:184

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

av_buffer_create

AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)

Create an AVBuffer from an existing array.

Definition: buffer.c:55

error.h

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

cudaVideoSurfaceFormat_YUV444_16Bit

#define cudaVideoSurfaceFormat_YUV444_16Bit

Definition: nvdec.c:43

nvdec_alloc_dummy

static AVBufferRef * nvdec_alloc_dummy(size_t size)

Definition: nvdec.c:283

CHECK_CU

#define CHECK_CU(x)

Definition: nvdec.c:65

NVDECDecoder::real_hw_frames_ref

AVBufferRef * real_hw_frames_ref

Definition: nvdec.c:50

FrameDecodeData::post_process

int(* post_process)(void *logctx, AVFrame *frame)

The callback to perform some delayed processing on the frame right before it is returned to the calle...

Definition: decode.h:44

AVCodecInternal::hwaccel_priv_data

void * hwaccel_priv_data

hwaccel-specific private data

Definition: internal.h:130

NVDECFrame::ref_idx_ref

unsigned int * ref_idx_ref

RefStruct reference.

Definition: nvdec.h:48

size

int size

Definition: twinvq_data.h:10344

FFRefStructOpaque::nc

void * nc

Definition: refstruct.h:59

nvdec_test_capabilities

static int nvdec_test_capabilities(NVDECDecoder *decoder, CUVIDDECODECREATEINFO *params, void *logctx)

Definition: nvdec.c:106

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

nvdec.h

nvdec_free_dummy

static void nvdec_free_dummy(struct AVHWFramesContext *ctx)

Definition: nvdec.c:278

ff_nvdec_decode_uninit

int ff_nvdec_decode_uninit(AVCodecContext *avctx)

Definition: nvdec.c:259

AV_CODEC_ID_MJPEG

@ AV_CODEC_ID_MJPEG

Definition: codec_id.h:59

NVDECFrame::decoder

struct NVDECDecoder * decoder

RefStruct reference.

Definition: nvdec.h:49

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

hw_device_ctx

static AVBufferRef * hw_device_ctx

Definition: hw_decode.c:45

NVDECDecoder::cuda_ctx

CUcontext cuda_ctx

Definition: nvdec.c:51

nvdec_fdd_priv_free

static void nvdec_fdd_priv_free(void *priv)

Definition: nvdec.c:443

ff_nvdec_end_frame

int ff_nvdec_end_frame(AVCodecContext *avctx)

Definition: nvdec.c:633

common.h

AVCodecContext::hwaccel_flags

int hwaccel_flags

Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).

Definition: avcodec.h:1516

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:226

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

AVCodecContext::hw_device_ctx

AVBufferRef * hw_device_ctx

A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...

Definition: avcodec.h:1507

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:122

av_buffer_replace

int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)

Ensure dst refers to the same data as src.

Definition: buffer.c:233

NVDECDecoder

Definition: nvdec.c:46

AV_PIX_FMT_P016

#define AV_PIX_FMT_P016

Definition: pixfmt.h:530

AVCodecContext::hw_frames_ctx

AVBufferRef * hw_frames_ctx

A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.

Definition: avcodec.h:1485

avcodec.h

nvdec_retrieve_data

static int nvdec_retrieve_data(void *logctx, AVFrame *frame)

Definition: nvdec.c:481

AVHWFramesContext

This struct describes a set or pool of "hardware" frames (i.e.

Definition: hwcontext.h:115

AVCUDADeviceContext

This struct is allocated as AVHWDeviceContext.hwctx.

Definition: hwcontext_cuda.h:42

avcodec_get_hw_frames_parameters

int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, AVBufferRef *device_ref, enum AVPixelFormat hw_pix_fmt, AVBufferRef **out_frames_ref)

Create and return a AVHWFramesContext with values adequate for hardware decoding.

Definition: decode.c:1167

ret

Definition: filter_design.txt:187

pixfmt.h

AV_PIX_FMT_NV12

@ AV_PIX_FMT_NV12

planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...

Definition: pixfmt.h:96

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

cuda_check.h

NVDECFramePool::dpb_size

unsigned int dpb_size

Definition: nvdec.c:61

nvdec_init_hwframes

static int nvdec_init_hwframes(AVCodecContext *avctx, AVBufferRef **out_frames_ref, int dummy)

Definition: nvdec.c:288

NVDECFramePool::nb_allocated

unsigned int nb_allocated

Definition: nvdec.c:62

AVCodecContext

main external API structure.

Definition: avcodec.h:451

ff_nvdec_simple_decode_slice

int ff_nvdec_simple_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)

Definition: nvdec.c:673

nvdec_unmap_mapped_frame

static void nvdec_unmap_mapped_frame(void *opaque, uint8_t *data)

Definition: nvdec.c:457

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

ff_nvdec_frame_params

int ff_nvdec_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx, int dpb_size, int supports_444)

Definition: nvdec.c:695

ff_refstruct_pool_alloc_ext

static FFRefStructPool * ff_refstruct_pool_alloc_ext(size_t size, unsigned flags, void *opaque, int(*init_cb)(FFRefStructOpaque opaque, void *obj), void(*reset_cb)(FFRefStructOpaque opaque, void *obj), void(*free_entry_cb)(FFRefStructOpaque opaque, void *obj), void(*free_cb)(FFRefStructOpaque opaque))

A wrapper around ff_refstruct_pool_alloc_ext_c() for the common case of a non-const qualified opaque.

Definition: refstruct.h:258

output_format

static char * output_format

Definition: ffprobe.c:150

AVPixFmtDescriptor::comp

AVComponentDescriptor comp[4]

Parameters that describe how pixels are packed.

Definition: pixdesc.h:105

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)