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