FFmpeg: libavcodec/nvdec_av1.c Source File

FFmpeg
nvdec_av1.c
Go to the documentation of this file.
1 /*
2  * AV1 HW decode acceleration through NVDEC
3  *
4  * Copyright (c) 2020 Timo Rothenpieler
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 "libavutil/mem.h"
24 #include "avcodec.h"
25 #include "nvdec.h"
26 #include "decode.h"
27 #include "hwaccel_internal.h"
28 #include "internal.h"
29 #include "av1dec.h"
30 
31 
32  static int get_bit_depth_from_seq(const AV1RawSequenceHeader *seq)
33 {
34  if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
35  return seq->color_config.twelve_bit ? 12 : 10;
36  else if (seq->seq_profile <= 2 && seq->color_config.high_bitdepth)
37  return 10;
38  else
39  return 8;
40 }
41 
42  static int nvdec_av1_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
43 {
44  const AV1DecContext *s = avctx->priv_data;
45  const AV1RawSequenceHeader *seq = s->raw_seq;
46  const AV1RawFrameHeader *frame_header = s->raw_frame_header;
47  const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
48 
49  NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
50  CUVIDPICPARAMS *pp = &ctx->pic_params;
51  CUVIDAV1PICPARAMS *ppc = &pp->CodecSpecific.av1;
52  FrameDecodeData *fdd;
53  NVDECFrame *cf;
54  AVFrame *cur_frame = s->cur_frame.f;
55 
56  unsigned char remap_lr_type[4] = { AV1_RESTORE_NONE, AV1_RESTORE_SWITCHABLE, AV1_RESTORE_WIENER, AV1_RESTORE_SGRPROJ };
57 
58  int apply_grain = !(avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN) && film_grain->apply_grain;
59  int ret, i, j;
60 
61  ret = ff_nvdec_start_frame_sep_ref(avctx, cur_frame, apply_grain);
62  if (ret < 0)
63  return ret;
64 
65  fdd = (FrameDecodeData*)cur_frame->private_ref->data;
66  cf = (NVDECFrame*)fdd->hwaccel_priv;
67 
68  *pp = (CUVIDPICPARAMS) {
69  .PicWidthInMbs = (cur_frame->width + 15) / 16,
70  .FrameHeightInMbs = (cur_frame->height + 15) / 16,
71  .CurrPicIdx = cf->idx,
72  .ref_pic_flag = !!frame_header->refresh_frame_flags,
73  .intra_pic_flag = frame_header->frame_type == AV1_FRAME_INTRA_ONLY ||
74  frame_header->frame_type == AV1_FRAME_KEY,
75 
76  .CodecSpecific.av1 = {
77  .width = cur_frame->width,
78  .height = cur_frame->height,
79 
80  .frame_offset = frame_header->order_hint,
81  .decodePicIdx = cf->ref_idx,
82 
83  /* Sequence Header */
84  .profile = seq->seq_profile,
85  .use_128x128_superblock = seq->use_128x128_superblock,
86  .subsampling_x = seq->color_config.subsampling_x,
87  .subsampling_y = seq->color_config.subsampling_y,
88  .mono_chrome = seq->color_config.mono_chrome,
89  .bit_depth_minus8 = get_bit_depth_from_seq(seq) - 8,
90  .enable_filter_intra = seq->enable_filter_intra,
91  .enable_intra_edge_filter = seq->enable_intra_edge_filter,
92  .enable_interintra_compound = seq->enable_interintra_compound,
93  .enable_masked_compound = seq->enable_masked_compound,
94  .enable_dual_filter = seq->enable_dual_filter,
95  .enable_order_hint = seq->enable_order_hint,
96  .order_hint_bits_minus1 = seq->order_hint_bits_minus_1,
97  .enable_jnt_comp = seq->enable_jnt_comp,
98  .enable_superres = seq->enable_superres,
99  .enable_cdef = seq->enable_cdef,
100  .enable_restoration = seq->enable_restoration,
101  .enable_fgs = seq->film_grain_params_present &&
102  !(avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN),
103 
104  /* Frame Header */
105  .frame_type = frame_header->frame_type,
106  .show_frame = frame_header->show_frame,
107  .disable_cdf_update = frame_header->disable_cdf_update,
108  .allow_screen_content_tools = frame_header->allow_screen_content_tools,
109  .force_integer_mv = s->cur_frame.force_integer_mv,
110  .coded_denom = frame_header->coded_denom,
111  .allow_intrabc = frame_header->allow_intrabc,
112  .allow_high_precision_mv = frame_header->allow_high_precision_mv,
113  .interp_filter = frame_header->interpolation_filter,
114  .switchable_motion_mode = frame_header->is_motion_mode_switchable,
115  .use_ref_frame_mvs = frame_header->use_ref_frame_mvs,
116  .disable_frame_end_update_cdf = frame_header->disable_frame_end_update_cdf,
117  .delta_q_present = frame_header->delta_q_present,
118  .delta_q_res = frame_header->delta_q_res,
119  .using_qmatrix = frame_header->using_qmatrix,
120  .coded_lossless = s->cur_frame.coded_lossless,
121  .use_superres = frame_header->use_superres,
122  .tx_mode = frame_header->tx_mode,
123  .reference_mode = frame_header->reference_select,
124  .allow_warped_motion = frame_header->allow_warped_motion,
125  .reduced_tx_set = frame_header->reduced_tx_set,
126  .skip_mode = frame_header->skip_mode_present,
127 
128  /* Tiling Info */
129  .num_tile_cols = frame_header->tile_cols,
130  .num_tile_rows = frame_header->tile_rows,
131  .context_update_tile_id = frame_header->context_update_tile_id,
132 
133  /* CDEF */
134  .cdef_damping_minus_3 = frame_header->cdef_damping_minus_3,
135  .cdef_bits = frame_header->cdef_bits,
136 
137  /* SkipModeFrames */
138  .SkipModeFrame0 = frame_header->skip_mode_present ?
139  s->cur_frame.skip_mode_frame_idx[0] : 0,
140  .SkipModeFrame1 = frame_header->skip_mode_present ?
141  s->cur_frame.skip_mode_frame_idx[1] : 0,
142 
143  /* QP Information */
144  .base_qindex = frame_header->base_q_idx,
145  .qp_y_dc_delta_q = frame_header->delta_q_y_dc,
146  .qp_u_dc_delta_q = frame_header->delta_q_u_dc,
147  .qp_v_dc_delta_q = frame_header->delta_q_v_dc,
148  .qp_u_ac_delta_q = frame_header->delta_q_u_ac,
149  .qp_v_ac_delta_q = frame_header->delta_q_v_ac,
150  .qm_y = frame_header->qm_y,
151  .qm_u = frame_header->qm_u,
152  .qm_v = frame_header->qm_v,
153 
154  /* Segmentation */
155  .segmentation_enabled = frame_header->segmentation_enabled,
156  .segmentation_update_map = frame_header->segmentation_update_map,
157  .segmentation_update_data = frame_header->segmentation_update_data,
158  .segmentation_temporal_update = frame_header->segmentation_temporal_update,
159 
160  /* Loopfilter */
161  .loop_filter_level[0] = frame_header->loop_filter_level[0],
162  .loop_filter_level[1] = frame_header->loop_filter_level[1],
163  .loop_filter_level_u = frame_header->loop_filter_level[2],
164  .loop_filter_level_v = frame_header->loop_filter_level[3],
165  .loop_filter_sharpness = frame_header->loop_filter_sharpness,
166  .loop_filter_delta_enabled = frame_header->loop_filter_delta_enabled,
167  .loop_filter_delta_update = frame_header->loop_filter_delta_update,
168  .loop_filter_mode_deltas[0] = frame_header->loop_filter_mode_deltas[0],
169  .loop_filter_mode_deltas[1] = frame_header->loop_filter_mode_deltas[1],
170  .delta_lf_present = frame_header->delta_lf_present,
171  .delta_lf_res = frame_header->delta_lf_res,
172  .delta_lf_multi = frame_header->delta_lf_multi,
173 
174  /* Restoration */
175  .lr_type[0] = remap_lr_type[frame_header->lr_type[0]],
176  .lr_type[1] = remap_lr_type[frame_header->lr_type[1]],
177  .lr_type[2] = remap_lr_type[frame_header->lr_type[2]],
178  .lr_unit_size[0] = 1 + frame_header->lr_unit_shift,
179  .lr_unit_size[1] = 1 + frame_header->lr_unit_shift - frame_header->lr_uv_shift,
180  .lr_unit_size[2] = 1 + frame_header->lr_unit_shift - frame_header->lr_uv_shift,
181 
182  /* Reference Frames */
183  .temporal_layer_id = s->cur_frame.temporal_id,
184  .spatial_layer_id = s->cur_frame.spatial_id,
185 
186  /* Film Grain Params */
187  .apply_grain = apply_grain,
188  .overlap_flag = film_grain->overlap_flag,
189  .scaling_shift_minus8 = film_grain->grain_scaling_minus_8,
190  .chroma_scaling_from_luma = film_grain->chroma_scaling_from_luma,
191  .ar_coeff_lag = film_grain->ar_coeff_lag,
192  .ar_coeff_shift_minus6 = film_grain->ar_coeff_shift_minus_6,
193  .grain_scale_shift = film_grain->grain_scale_shift,
194  .clip_to_restricted_range = film_grain->clip_to_restricted_range,
195  .num_y_points = film_grain->num_y_points,
196  .num_cb_points = film_grain->num_cb_points,
197  .num_cr_points = film_grain->num_cr_points,
198  .random_seed = film_grain->grain_seed,
199  .cb_mult = film_grain->cb_mult,
200  .cb_luma_mult = film_grain->cb_luma_mult,
201  .cb_offset = film_grain->cb_offset,
202  .cr_mult = film_grain->cr_mult,
203  .cr_luma_mult = film_grain->cr_luma_mult,
204  .cr_offset = film_grain->cr_offset
205  }
206  };
207 
208  /* Tiling Info */
209  for (i = 0; i < frame_header->tile_cols; ++i) {
210  ppc->tile_widths[i] = frame_header->width_in_sbs_minus_1[i] + 1;
211  }
212  for (i = 0; i < frame_header->tile_rows; ++i) {
213  ppc->tile_heights[i] = frame_header->height_in_sbs_minus_1[i] + 1;
214  }
215 
216  /* CDEF */
217  for (i = 0; i < (1 << frame_header->cdef_bits); ++i) {
218  ppc->cdef_y_strength[i] = (frame_header->cdef_y_pri_strength[i] & 0x0F) | (frame_header->cdef_y_sec_strength[i] << 4);
219  ppc->cdef_uv_strength[i] = (frame_header->cdef_uv_pri_strength[i] & 0x0F) | (frame_header->cdef_uv_sec_strength[i] << 4);
220  }
221 
222  /* Segmentation */
223  for (i = 0; i < AV1_MAX_SEGMENTS; ++i) {
224  ppc->segmentation_feature_mask[i] = 0;
225  for (j = 0; j < AV1_SEG_LVL_MAX; ++j) {
226  ppc->segmentation_feature_mask[i] |= frame_header->feature_enabled[i][j] << j;
227  ppc->segmentation_feature_data[i][j] = frame_header->feature_value[i][j];
228  }
229  }
230 
231  for (i = 0; i < AV1_NUM_REF_FRAMES; ++i) {
232  /* Loopfilter */
233  ppc->loop_filter_ref_deltas[i] = frame_header->loop_filter_ref_deltas[i];
234 
235  /* Reference Frames */
236  ppc->ref_frame_map[i] = ff_nvdec_get_ref_idx(s->ref[i].f);
237  }
238 
239  if (frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
240  ppc->primary_ref_frame = -1;
241  } else {
242  int8_t pri_ref_idx = frame_header->ref_frame_idx[frame_header->primary_ref_frame];
243  ppc->primary_ref_frame = ppc->ref_frame_map[pri_ref_idx];
244  }
245 
246  for (i = 0; i < AV1_REFS_PER_FRAME; ++i) {
247  /* Ref Frame List */
248  int8_t ref_idx = frame_header->ref_frame_idx[i];
249  AVFrame *ref_frame = s->ref[ref_idx].f;
250 
251  ppc->ref_frame[i].index = ppc->ref_frame_map[ref_idx];
252  ppc->ref_frame[i].width = ref_frame ? ref_frame->width : 0;
253  ppc->ref_frame[i].height = ref_frame ? ref_frame->height : 0;
254 
255  /* Global Motion */
256  ppc->global_motion[i].invalid = !frame_header->is_global[AV1_REF_FRAME_LAST + i];
257  ppc->global_motion[i].wmtype = s->cur_frame.gm_type[AV1_REF_FRAME_LAST + i];
258  for (j = 0; j < 6; ++j) {
259  ppc->global_motion[i].wmmat[j] = s->cur_frame.gm_params[AV1_REF_FRAME_LAST + i][j];
260  }
261  }
262 
263  /* Film Grain Params */
264  if (apply_grain) {
265  for (i = 0; i < 14; ++i) {
266  ppc->scaling_points_y[i][0] = film_grain->point_y_value[i];
267  ppc->scaling_points_y[i][1] = film_grain->point_y_scaling[i];
268  }
269  for (i = 0; i < 10; ++i) {
270  ppc->scaling_points_cb[i][0] = film_grain->point_cb_value[i];
271  ppc->scaling_points_cb[i][1] = film_grain->point_cb_scaling[i];
272  ppc->scaling_points_cr[i][0] = film_grain->point_cr_value[i];
273  ppc->scaling_points_cr[i][1] = film_grain->point_cr_scaling[i];
274  }
275  for (i = 0; i < 24; ++i) {
276  ppc->ar_coeffs_y[i] = (short)film_grain->ar_coeffs_y_plus_128[i] - 128;
277  }
278  for (i = 0; i < 25; ++i) {
279  ppc->ar_coeffs_cb[i] = (short)film_grain->ar_coeffs_cb_plus_128[i] - 128;
280  ppc->ar_coeffs_cr[i] = (short)film_grain->ar_coeffs_cr_plus_128[i] - 128;
281  }
282  }
283 
284  return 0;
285 }
286 
287  static int nvdec_av1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
288 {
289  const AV1DecContext *s = avctx->priv_data;
290  const AV1RawFrameHeader *frame_header = s->raw_frame_header;
291  NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
292  void *tmp;
293 
294  ctx->nb_slices = frame_header->tile_cols * frame_header->tile_rows;
295 
296  tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
297  ctx->nb_slices * 2 * sizeof(*ctx->slice_offsets));
298  if (!tmp) {
299  return AVERROR(ENOMEM);
300  }
301  ctx->slice_offsets = tmp;
302 
303  /* Shortcut if all tiles are in the same buffer */
304  if (ctx->nb_slices == s->tg_end - s->tg_start + 1) {
305  ctx->bitstream = buffer;
306  ctx->bitstream_len = size;
307 
308  for (int i = 0; i < ctx->nb_slices; ++i) {
309  ctx->slice_offsets[i*2 ] = s->tile_group_info[i].tile_offset;
310  ctx->slice_offsets[i*2 + 1] = ctx->slice_offsets[i*2] + s->tile_group_info[i].tile_size;
311  }
312 
313  return 0;
314  }
315 
316  tmp = av_fast_realloc(ctx->bitstream_internal, &ctx->bitstream_allocated,
317  ctx->bitstream_len + size);
318  if (!tmp) {
319  return AVERROR(ENOMEM);
320  }
321  ctx->bitstream = ctx->bitstream_internal = tmp;
322 
323  memcpy(ctx->bitstream_internal + ctx->bitstream_len, buffer, size);
324 
325  for (uint32_t tile_num = s->tg_start; tile_num <= s->tg_end; ++tile_num) {
326  ctx->slice_offsets[tile_num*2 ] = ctx->bitstream_len + s->tile_group_info[tile_num].tile_offset;
327  ctx->slice_offsets[tile_num*2 + 1] = ctx->slice_offsets[tile_num*2] + s->tile_group_info[tile_num].tile_size;
328  }
329  ctx->bitstream_len += size;
330 
331  return 0;
332 }
333 
334  static int nvdec_av1_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
335 {
336  /* Maximum of 8 reference frames, but potentially stored twice due to film grain */
337  return ff_nvdec_frame_params(avctx, hw_frames_ctx, 8 * 2, 0);
338 }
339 
340  const FFHWAccel ff_av1_nvdec_hwaccel = {
341  .p.name = "av1_nvdec",
342  .p.type = AVMEDIA_TYPE_VIDEO,
343  .p.id = AV_CODEC_ID_AV1,
344  .p.pix_fmt = AV_PIX_FMT_CUDA,
345  .start_frame = nvdec_av1_start_frame,
346  .end_frame = ff_nvdec_simple_end_frame,
347  .decode_slice = nvdec_av1_decode_slice,
348  .frame_params = nvdec_av1_frame_params,
349  .init = ff_nvdec_decode_init,
350  .uninit = ff_nvdec_decode_uninit,
351  .priv_data_size = sizeof(NVDECContext),
352 };
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
AV1RawFilmGrainParams::clip_to_restricted_range
uint8_t clip_to_restricted_range
Definition: cbs_av1.h:162
AV1RawFilmGrainParams::grain_seed
uint16_t grain_seed
Definition: cbs_av1.h:135
AV1RawSequenceHeader
Definition: cbs_av1.h:73
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:63
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV1RawFilmGrainParams::point_cb_value
uint8_t point_cb_value[10]
Definition: cbs_av1.h:143
AV1RawFilmGrainParams::apply_grain
uint8_t apply_grain
Definition: cbs_av1.h:134
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:85
ff_nvdec_get_ref_idx
int ff_nvdec_get_ref_idx(AVFrame *frame)
Definition: nvdec.c:747
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
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
AVFrame::width
int width
Definition: frame.h:461
AV1RawFilmGrainParams::point_y_value
uint8_t point_y_value[14]
Definition: cbs_av1.h:139
internal.h
AV1_RESTORE_SGRPROJ
@ AV1_RESTORE_SGRPROJ
Definition: av1.h:175
AV1RawSequenceHeader::seq_profile
uint8_t seq_profile
Definition: cbs_av1.h:74
AV1RawColorConfig::subsampling_y
uint8_t subsampling_y
Definition: cbs_av1.h:53
AV1_RESTORE_WIENER
@ AV1_RESTORE_WIENER
Definition: av1.h:174
AV1RawFilmGrainParams::cr_mult
uint8_t cr_mult
Definition: cbs_av1.h:158
AV1RawFilmGrainParams::chroma_scaling_from_luma
uint8_t chroma_scaling_from_luma
Definition: cbs_av1.h:141
AV1RawFilmGrainParams::ar_coeffs_cr_plus_128
uint8_t ar_coeffs_cr_plus_128[25]
Definition: cbs_av1.h:152
AV1RawSequenceHeader::film_grain_params_present
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
FFHWAccel
Definition: hwaccel_internal.h:34
NVDECFrame::ref_idx
unsigned int ref_idx
Definition: nvdec.h:46
AV1RawSequenceHeader::enable_filter_intra
uint8_t enable_filter_intra
Definition: cbs_av1.h:106
AV1RawFilmGrainParams::point_cr_scaling
uint8_t point_cr_scaling[10]
Definition: cbs_av1.h:147
AV1RawFilmGrainParams::ar_coeff_shift_minus_6
uint8_t ar_coeff_shift_minus_6
Definition: cbs_av1.h:153
AV1RawFilmGrainParams::num_y_points
uint8_t num_y_points
Definition: cbs_av1.h:138
AV1RawFilmGrainParams::num_cb_points
uint8_t num_cb_points
Definition: cbs_av1.h:142
AV1RawFilmGrainParams::cb_luma_mult
uint8_t cb_luma_mult
Definition: cbs_av1.h:156
AV1RawFilmGrainParams::overlap_flag
uint8_t overlap_flag
Definition: cbs_av1.h:161
AV1RawSequenceHeader::enable_masked_compound
uint8_t enable_masked_compound
Definition: cbs_av1.h:109
AV1RawFilmGrainParams::grain_scaling_minus_8
uint8_t grain_scaling_minus_8
Definition: cbs_av1.h:148
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
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
NVDECFrame
Definition: nvdec.h:44
ctx
AVFormatContext * ctx
Definition: movenc.c:49
decode.h
av1dec.h
get_bit_depth_from_seq
static int get_bit_depth_from_seq(const AV1RawSequenceHeader *seq)
Definition: nvdec_av1.c:32
nvdec_av1_frame_params
static int nvdec_av1_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: nvdec_av1.c:334
ff_nvdec_simple_end_frame
int ff_nvdec_simple_end_frame(AVCodecContext *avctx)
Definition: nvdec.c:663
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:84
AV1RawFilmGrainParams::cb_mult
uint8_t cb_mult
Definition: cbs_av1.h:155
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
hwaccel_internal.h
AV1RawFrameHeader
Definition: cbs_av1.h:165
ff_nvdec_decode_init
int ff_nvdec_decode_init(AVCodecContext *avctx)
Definition: nvdec.c:327
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
AV1_RESTORE_NONE
@ AV1_RESTORE_NONE
Definition: av1.h:173
AV1RawSequenceHeader::enable_jnt_comp
uint8_t enable_jnt_comp
Definition: cbs_av1.h:114
AV1_RESTORE_SWITCHABLE
@ AV1_RESTORE_SWITCHABLE
Definition: av1.h:176
AV1RawFilmGrainParams::point_cr_value
uint8_t point_cr_value[10]
Definition: cbs_av1.h:146
nvdec_av1_start_frame
static int nvdec_av1_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_av1.c:42
AV1RawFilmGrainParams::cb_offset
uint16_t cb_offset
Definition: cbs_av1.h:157
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:130
NVDECFrame::idx
unsigned int idx
Definition: nvdec.h:45
size
int size
Definition: twinvq_data.h:10344
AV1DecContext
Definition: av1dec.h:85
AV1RawSequenceHeader::use_128x128_superblock
uint8_t use_128x128_superblock
Definition: cbs_av1.h:105
ref_frame
static int ref_frame(VVCFrame *dst, const VVCFrame *src)
Definition: dec.c:596
nvdec_av1_decode_slice
static int nvdec_av1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_av1.c:287
nvdec.h
AV1RawFilmGrainParams::grain_scale_shift
uint8_t grain_scale_shift
Definition: cbs_av1.h:154
AV1RawSequenceHeader::enable_interintra_compound
uint8_t enable_interintra_compound
Definition: cbs_av1.h:108
ff_nvdec_decode_uninit
int ff_nvdec_decode_uninit(AVCodecContext *avctx)
Definition: nvdec.c:259
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:87
AVFrame::private_ref
AVBufferRef * private_ref
AVBufferRef for internal use by a single libav* library.
Definition: frame.h:785
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2105
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AV1RawSequenceHeader::enable_dual_filter
uint8_t enable_dual_filter
Definition: cbs_av1.h:111
frame_type
frame_type
Definition: jpeg2000_parser.c:31
AV1RawSequenceHeader::enable_superres
uint8_t enable_superres
Definition: cbs_av1.h:124
AV1RawSequenceHeader::enable_intra_edge_filter
uint8_t enable_intra_edge_filter
Definition: cbs_av1.h:107
AV1RawSequenceHeader::color_config
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
AV1RawSequenceHeader::enable_order_hint
uint8_t enable_order_hint
Definition: cbs_av1.h:113
avcodec.h
ret
ret
Definition: filter_design.txt:187
AV1RawColorConfig::subsampling_x
uint8_t subsampling_x
Definition: cbs_av1.h:52
AV1RawColorConfig::high_bitdepth
uint8_t high_bitdepth
Definition: cbs_av1.h:42
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:89
AV1RawFilmGrainParams::cr_luma_mult
uint8_t cr_luma_mult
Definition: cbs_av1.h:159
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVFrame::height
int height
Definition: frame.h:461
frame_header
Definition: truemotion1.c:88
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
AV1RawFilmGrainParams::ar_coeff_lag
uint8_t ar_coeff_lag
Definition: cbs_av1.h:149
AV1RawColorConfig::mono_chrome
uint8_t mono_chrome
Definition: cbs_av1.h:44
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1937
AV1RawFilmGrainParams::ar_coeffs_cb_plus_128
uint8_t ar_coeffs_cb_plus_128[25]
Definition: cbs_av1.h:151
AV1RawFilmGrainParams::ar_coeffs_y_plus_128
uint8_t ar_coeffs_y_plus_128[24]
Definition: cbs_av1.h:150
AV1RawSequenceHeader::order_hint_bits_minus_1
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
AV1RawFilmGrainParams::cr_offset
uint16_t cr_offset
Definition: cbs_av1.h:160
AV1RawFilmGrainParams::point_y_scaling
uint8_t point_y_scaling[14]
Definition: cbs_av1.h:140
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AV1RawFilmGrainParams::point_cb_scaling
uint8_t point_cb_scaling[10]
Definition: cbs_av1.h:144
AV1RawSequenceHeader::enable_restoration
uint8_t enable_restoration
Definition: cbs_av1.h:126
AV1RawColorConfig::twelve_bit
uint8_t twelve_bit
Definition: cbs_av1.h:43
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV1RawSequenceHeader::enable_cdef
uint8_t enable_cdef
Definition: cbs_av1.h:125
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
AV1RawFilmGrainParams
Definition: cbs_av1.h:133
NVDECContext
Definition: nvdec.h:52
short
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 default minimum maximum flags name is the option keep it simple and lowercase description are short
Definition: writing_filters.txt:89
AV1_SEG_LVL_MAX
@ AV1_SEG_LVL_MAX
Definition: av1.h:90
AV1RawFilmGrainParams::num_cr_points
uint8_t num_cr_points
Definition: cbs_av1.h:145
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:420
ff_av1_nvdec_hwaccel
const FFHWAccel ff_av1_nvdec_hwaccel
Definition: nvdec_av1.c:340
Generated on Fri Aug 22 2025 13:58:43 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /