FFmpeg
nvdec_hevc.c
Go to the documentation of this file.
1 /*
2  * HEVC HW decode acceleration through NVDEC
3  *
4  * Copyright (c) 2017 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 <stdint.h>
24 #include <string.h>
25 
26 #include "avcodec.h"
27 #include "nvdec.h"
28 #include "decode.h"
29 #include "internal.h"
30 #include "hevcdec.h"
31 #include "hevc_data.h"
32 #include "hwaccel_internal.h"
33 
34 static void dpb_add(CUVIDHEVCPICPARAMS *pp, int idx, const HEVCFrame *src)
35 {
36  FrameDecodeData *fdd = (FrameDecodeData*)src->frame->private_ref->data;
37  const NVDECFrame *cf = fdd->hwaccel_priv;
38 
39  pp->RefPicIdx[idx] = cf ? cf->idx : -1;
40  pp->PicOrderCntVal[idx] = src->poc;
41  pp->IsLongTerm[idx] = !!(src->flags & HEVC_FRAME_FLAG_LONG_REF);
42 }
43 
44 static void fill_scaling_lists(CUVIDHEVCPICPARAMS *ppc, const HEVCContext *s)
45 {
46  const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
47  &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
48  int i, j, pos;
49 
50  for (i = 0; i < 6; i++) {
51  for (j = 0; j < 16; j++) {
53  ppc->ScalingList4x4[i][j] = sl->sl[0][i][pos];
54  }
55 
56  for (j = 0; j < 64; j++) {
58  ppc->ScalingList8x8[i][j] = sl->sl[1][i][pos];
59  ppc->ScalingList16x16[i][j] = sl->sl[2][i][pos];
60 
61  if (i < 2)
62  ppc->ScalingList32x32[i][j] = sl->sl[3][i * 3][pos];
63  }
64 
65  ppc->ScalingListDCCoeff16x16[i] = sl->sl_dc[0][i];
66  if (i < 2)
67  ppc->ScalingListDCCoeff32x32[i] = sl->sl_dc[1][i * 3];
68  }
69 }
70 
72  const uint8_t *buffer, uint32_t size)
73 {
74  const HEVCContext *s = avctx->priv_data;
75  const HEVCPPS *pps = s->ps.pps;
76  const HEVCSPS *sps = s->ps.sps;
77 
79  CUVIDPICPARAMS *pp = &ctx->pic_params;
80  CUVIDHEVCPICPARAMS *ppc = &pp->CodecSpecific.hevc;
81  FrameDecodeData *fdd;
82  NVDECFrame *cf;
83 
84  int i, j, dpb_size, ret;
85 
86  ret = ff_nvdec_start_frame(avctx, s->ref->frame);
87  if (ret < 0)
88  return ret;
89 
90  fdd = (FrameDecodeData*)s->ref->frame->private_ref->data;
91  cf = (NVDECFrame*)fdd->hwaccel_priv;
92 
93  *pp = (CUVIDPICPARAMS) {
94  .PicWidthInMbs = sps->width / 16,
95  .FrameHeightInMbs = sps->height / 16,
96  .CurrPicIdx = cf->idx,
97  .ref_pic_flag = 1,
98  .intra_pic_flag = IS_IRAP(s),
99 
100  .CodecSpecific.hevc = {
101  .pic_width_in_luma_samples = sps->width,
102  .pic_height_in_luma_samples = sps->height,
103  .log2_min_luma_coding_block_size_minus3 = sps->log2_min_cb_size - 3,
104  .log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_coding_block_size,
105  .log2_min_transform_block_size_minus2 = sps->log2_min_tb_size - 2,
106  .log2_diff_max_min_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size,
107  .pcm_enabled_flag = sps->pcm_enabled_flag,
108  .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm_enabled_flag ? sps->pcm.log2_min_pcm_cb_size - 3 : 0,
109  .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,
110  .pcm_sample_bit_depth_luma_minus1 = sps->pcm_enabled_flag ? sps->pcm.bit_depth - 1 : 0,
111  .pcm_sample_bit_depth_chroma_minus1 = sps->pcm_enabled_flag ? sps->pcm.bit_depth_chroma - 1 : 0,
112 #if NVDECAPI_CHECK_VERSION(8, 1)
113  .log2_max_transform_skip_block_size_minus2 = pps->log2_max_transform_skip_block_size - 2,
114  .log2_sao_offset_scale_luma = pps->log2_sao_offset_scale_luma,
115  .log2_sao_offset_scale_chroma = pps->log2_sao_offset_scale_chroma,
116  .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled_flag,
117 #endif
118  .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag,
119  .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag,
120  .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,
121  .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,
122  .amp_enabled_flag = sps->amp_enabled_flag,
123  .separate_colour_plane_flag = sps->separate_colour_plane_flag,
124  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,
125  .num_short_term_ref_pic_sets = sps->nb_st_rps,
126  .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,
127  .num_long_term_ref_pics_sps = sps->num_long_term_ref_pics_sps,
128  .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
129  .sample_adaptive_offset_enabled_flag = sps->sao_enabled,
130  .scaling_list_enable_flag = sps->scaling_list_enable_flag,
131  .IrapPicFlag = IS_IRAP(s),
132  .IdrPicFlag = IS_IDR(s),
133  .bit_depth_luma_minus8 = sps->bit_depth - 8,
134  .bit_depth_chroma_minus8 = sps->bit_depth - 8,
135 #if NVDECAPI_CHECK_VERSION(9, 0)
136  .sps_range_extension_flag = sps->sps_range_extension_flag,
137  .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled_flag,
138  .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled_flag,
139  .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled_flag,
140  .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled_flag,
141  .extended_precision_processing_flag = sps->extended_precision_processing_flag,
142  .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled_flag,
143  .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled_flag,
144  .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled_flag,
145 #endif
146 
147  .dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,
148  .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag,
149  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag,
150  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
151  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
152  .init_qp_minus26 = pps->pic_init_qp_minus26,
153  .pps_cb_qp_offset = pps->cb_qp_offset,
154  .pps_cr_qp_offset = pps->cr_qp_offset,
155  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
156  .weighted_pred_flag = pps->weighted_pred_flag,
157  .weighted_bipred_flag = pps->weighted_bipred_flag,
158  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
159  .transquant_bypass_enabled_flag = pps->transquant_bypass_enable_flag,
160  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
161  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2,
162  .num_extra_slice_header_bits = pps->num_extra_slice_header_bits,
163  .loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,
164  .loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,
165  .output_flag_present_flag = pps->output_flag_present_flag,
166  .num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active - 1,
167  .num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active - 1,
168  .lists_modification_present_flag = pps->lists_modification_present_flag,
169  .cabac_init_present_flag = pps->cabac_init_present_flag,
170  .pps_slice_chroma_qp_offsets_present_flag = pps->pic_slice_level_chroma_qp_offsets_present_flag,
171  .deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag,
172  .pps_deblocking_filter_disabled_flag = pps->disable_dbf,
173  .pps_beta_offset_div2 = pps->beta_offset / 2,
174  .pps_tc_offset_div2 = pps->tc_offset / 2,
175  .tiles_enabled_flag = pps->tiles_enabled_flag,
176  .uniform_spacing_flag = pps->uniform_spacing_flag,
177  .num_tile_columns_minus1 = pps->num_tile_columns - 1,
178  .num_tile_rows_minus1 = pps->num_tile_rows - 1,
179 #if NVDECAPI_CHECK_VERSION(9, 0)
180  .pps_range_extension_flag = pps->pps_range_extensions_flag,
181  .cross_component_prediction_enabled_flag = pps->cross_component_prediction_enabled_flag,
182  .chroma_qp_offset_list_enabled_flag = pps->chroma_qp_offset_list_enabled_flag,
183  .diff_cu_chroma_qp_offset_depth = pps->diff_cu_chroma_qp_offset_depth,
184  .chroma_qp_offset_list_len_minus1 = pps->chroma_qp_offset_list_len_minus1,
185 #endif
186 
187  .NumBitsForShortTermRPSInSlice = s->sh.short_term_rps ? s->sh.short_term_ref_pic_set_size : 0,
188  .NumDeltaPocsOfRefRpsIdx = s->sh.short_term_rps ? s->sh.short_term_rps->rps_idx_num_delta_pocs : 0,
189  .NumPocTotalCurr = ff_hevc_frame_nb_refs(s),
190  .NumPocStCurrBefore = s->rps[ST_CURR_BEF].nb_refs,
191  .NumPocStCurrAfter = s->rps[ST_CURR_AFT].nb_refs,
192  .NumPocLtCurr = s->rps[LT_CURR].nb_refs,
193  .CurrPicOrderCntVal = s->ref->poc,
194  },
195  };
196 
197  if (pps->num_tile_columns > FF_ARRAY_ELEMS(ppc->column_width_minus1) ||
198  pps->num_tile_rows > FF_ARRAY_ELEMS(ppc->row_height_minus1)) {
199  av_log(avctx, AV_LOG_ERROR, "Too many tiles\n");
200  return AVERROR(ENOSYS);
201  }
202  for (i = 0; i < pps->num_tile_columns; i++)
203  ppc->column_width_minus1[i] = pps->column_width[i] - 1;
204  for (i = 0; i < pps->num_tile_rows; i++)
205  ppc->row_height_minus1[i] = pps->row_height[i] - 1;
206 
207 #if NVDECAPI_CHECK_VERSION(9, 0)
208  if (pps->chroma_qp_offset_list_len_minus1 >= FF_ARRAY_ELEMS(ppc->cb_qp_offset_list) ||
209  pps->chroma_qp_offset_list_len_minus1 >= FF_ARRAY_ELEMS(ppc->cr_qp_offset_list)) {
210  av_log(avctx, AV_LOG_ERROR, "Too many chroma_qp_offsets\n");
211  return AVERROR(ENOSYS);
212  }
213  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
214  ppc->cb_qp_offset_list[i] = pps->cb_qp_offset_list[i];
215  ppc->cr_qp_offset_list[i] = pps->cr_qp_offset_list[i];
216  }
217 #endif
218 
219  if (s->rps[LT_CURR].nb_refs > FF_ARRAY_ELEMS(ppc->RefPicSetLtCurr) ||
220  s->rps[ST_CURR_BEF].nb_refs > FF_ARRAY_ELEMS(ppc->RefPicSetStCurrBefore) ||
221  s->rps[ST_CURR_AFT].nb_refs > FF_ARRAY_ELEMS(ppc->RefPicSetStCurrAfter)) {
222  av_log(avctx, AV_LOG_ERROR, "Too many reference frames\n");
223  return AVERROR(ENOSYS);
224  }
225 
226  dpb_size = 0;
227  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
228  const HEVCFrame *ref = &s->DPB[i];
230  continue;
231  if (dpb_size >= FF_ARRAY_ELEMS(ppc->RefPicIdx)) {
232  av_log(avctx, AV_LOG_ERROR, "Too many reference frames\n");
233  return AVERROR_INVALIDDATA;
234  }
235  dpb_add(ppc, dpb_size++, ref);
236 
237  }
238  for (i = dpb_size; i < FF_ARRAY_ELEMS(ppc->RefPicIdx); i++)
239  ppc->RefPicIdx[i] = -1;
240 
241  for (i = 0; i < s->rps[ST_CURR_BEF].nb_refs; i++) {
242  for (j = 0; j < dpb_size; j++) {
243  if (ppc->PicOrderCntVal[j] == s->rps[ST_CURR_BEF].list[i]) {
244  ppc->RefPicSetStCurrBefore[i] = j;
245  break;
246  }
247  }
248  }
249  for (i = 0; i < s->rps[ST_CURR_AFT].nb_refs; i++) {
250  for (j = 0; j < dpb_size; j++) {
251  if (ppc->PicOrderCntVal[j] == s->rps[ST_CURR_AFT].list[i]) {
252  ppc->RefPicSetStCurrAfter[i] = j;
253  break;
254  }
255  }
256  }
257  for (i = 0; i < s->rps[LT_CURR].nb_refs; i++) {
258  for (j = 0; j < dpb_size; j++) {
259  if (ppc->PicOrderCntVal[j] == s->rps[LT_CURR].list[i]) {
260  ppc->RefPicSetLtCurr[i] = j;
261  break;
262  }
263  }
264  }
265 
266  fill_scaling_lists(ppc, s);
267 
268  return 0;
269 }
270 
271 static int nvdec_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
272  uint32_t size)
273 {
275  void *tmp;
276 
277  tmp = av_fast_realloc(ctx->bitstream_internal, &ctx->bitstream_allocated,
278  ctx->bitstream_len + size + 3);
279  if (!tmp)
280  return AVERROR(ENOMEM);
281  ctx->bitstream = ctx->bitstream_internal = tmp;
282 
283  tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
284  (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));
285  if (!tmp)
286  return AVERROR(ENOMEM);
287  ctx->slice_offsets = tmp;
288 
289  AV_WB24(ctx->bitstream_internal + ctx->bitstream_len, 1);
290  memcpy(ctx->bitstream_internal + ctx->bitstream_len + 3, buffer, size);
291  ctx->slice_offsets[ctx->nb_slices] = ctx->bitstream_len ;
292  ctx->bitstream_len += size + 3;
293  ctx->nb_slices++;
294 
295  return 0;
296 }
297 
299  AVBufferRef *hw_frames_ctx)
300 {
301  const HEVCContext *s = avctx->priv_data;
302  const HEVCSPS *sps = s->ps.sps;
303  return ff_nvdec_frame_params(avctx, hw_frames_ctx, sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering + 1, 1);
304 }
305 
308  ctx->supports_444 = 1;
309 
310  if (avctx->profile != AV_PROFILE_HEVC_MAIN &&
311  avctx->profile != AV_PROFILE_HEVC_MAIN_10 &&
313  avctx->profile != AV_PROFILE_HEVC_REXT) {
314  av_log(avctx, AV_LOG_ERROR, "Unsupported HEVC profile: %d\n", avctx->profile);
315  return AVERROR(ENOTSUP);
316  }
317 
318  return ff_nvdec_decode_init(avctx);
319 }
320 
322  .p.name = "hevc_nvdec",
323  .p.type = AVMEDIA_TYPE_VIDEO,
324  .p.id = AV_CODEC_ID_HEVC,
325  .p.pix_fmt = AV_PIX_FMT_CUDA,
326  .start_frame = nvdec_hevc_start_frame,
327  .end_frame = ff_nvdec_end_frame,
328  .decode_slice = nvdec_hevc_decode_slice,
329  .frame_params = nvdec_hevc_frame_params,
330  .init = nvdec_hevc_decode_init,
331  .uninit = ff_nvdec_decode_uninit,
332  .priv_data_size = sizeof(NVDECContext),
333 };
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
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
ff_hevc_diag_scan8x8_y
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_data.c:58
AV_PROFILE_HEVC_MAIN
#define AV_PROFILE_HEVC_MAIN
Definition: defs.h:158
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:33
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
internal.h
ScalingList::sl
uint8_t sl[4][6][64]
Definition: hevc_ps.h:182
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:400
FFHWAccel
Definition: hwaccel_internal.h:34
nvdec_hevc_frame_params
static int nvdec_hevc_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: nvdec_hevc.c:298
ff_nvdec_start_frame
int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: nvdec.c:560
NVDECAPI_CHECK_VERSION
#define NVDECAPI_CHECK_VERSION(major, minor)
Definition: nvdec.h:40
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
nvdec_hevc_decode_init
static int nvdec_hevc_decode_init(AVCodecContext *avctx)
Definition: nvdec_hevc.c:306
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:495
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_hevc_diag_scan8x8_x
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_data.c:39
NVDECFrame
Definition: nvdec.h:44
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:75
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:399
nvdec_hevc_decode_slice
static int nvdec_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_hevc.c:271
ScalingList
Definition: hevc_ps.h:179
dpb_size
int dpb_size
Definition: h264_levels.c:111
ff_hevc_diag_scan4x4_y
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
ScalingList::sl_dc
uint8_t sl_dc[2][6]
Definition: hevc_ps.h:183
hwaccel_internal.h
ff_nvdec_decode_init
int ff_nvdec_decode_init(AVCodecContext *avctx)
Definition: nvdec.c:326
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:476
AV_PROFILE_HEVC_MAIN_STILL_PICTURE
#define AV_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: defs.h:160
fill_scaling_lists
static void fill_scaling_lists(CUVIDHEVCPICPARAMS *ppc, const HEVCContext *s)
Definition: nvdec_hevc.c:44
AV_PROFILE_HEVC_MAIN_10
#define AV_PROFILE_HEVC_MAIN_10
Definition: defs.h:159
AV_PROFILE_HEVC_REXT
#define AV_PROFILE_HEVC_REXT
Definition: defs.h:161
hevc_data.h
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:78
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
hevcdec.h
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:121
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
NVDECFrame::idx
unsigned int idx
Definition: nvdec.h:45
size
int size
Definition: twinvq_data.h:10344
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:448
dpb_add
static void dpb_add(CUVIDHEVCPICPARAMS *pp, int idx, const HEVCFrame *src)
Definition: nvdec_hevc.c:34
nvdec.h
ff_nvdec_decode_uninit
int ff_nvdec_decode_uninit(AVCodecContext *avctx)
Definition: nvdec.c:258
nvdec_hevc_start_frame
static int nvdec_hevc_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_hevc.c:71
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2135
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
HEVCFrame
Definition: hevcdec.h:406
ff_nvdec_end_frame
int ff_nvdec_end_frame(AVCodecContext *avctx)
Definition: nvdec.c:632
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
ff_hevc_nvdec_hwaccel
const FFHWAccel ff_hevc_nvdec_hwaccel
Definition: nvdec_hevc.c:321
avcodec.h
ret
ret
Definition: filter_design.txt:187
ST_CURR_BEF
@ ST_CURR_BEF
Definition: hevcdec.h:81
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
pos
unsigned int pos
Definition: spdifenc.c:413
ff_hevc_frame_nb_refs
int ff_hevc_frame_nb_refs(const HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:535
LT_CURR
@ LT_CURR
Definition: hevcdec.h:84
AVCodecContext
main external API structure.
Definition: avcodec.h:441
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
HEVCContext
Definition: hevcdec.h:492
ff_nvdec_frame_params
int ff_nvdec_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx, int dpb_size, int supports_444)
Definition: nvdec.c:692
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1596
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ff_hevc_diag_scan4x4_x
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc_data.c:25
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
HEVCSPS
Definition: hevc_ps.h:186
HEVCPPS
Definition: hevc_ps.h:303
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:82
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
NVDECContext
Definition: nvdec.h:52