FFmpeg
d3d12va_encode_av1.c
Go to the documentation of this file.
1 /*
2  * Direct3D 12 HW acceleration video encoder
3  *
4  * Copyright (c) 2024 Intel Corporation
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/opt.h"
24 #include "libavutil/common.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/hwcontext_d3d12va_internal.h"
28 
29 #include "config_components.h"
30 #include "avcodec.h"
31 #include "cbs.h"
32 #include "cbs_av1.h"
33 #include "av1_levels.h"
34 #include "codec_internal.h"
35 #include "d3d12va_encode.h"
36 #include "encode.h"
37 #include "hw_base_encode.h"
38 
39 #include <d3d12.h>
40 #include <d3d12video.h>
41 
42 /* Added in Windows SDK 10.0.26100.0; define fallbacks for older SDKs. */
43 #ifndef D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_GRID_PARTITION
44 #define D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_GRID_PARTITION \
45  ((D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE)5)
46 #endif
47 #ifndef D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_CONFIGURABLE_GRID_PARTITION
48 #define D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_CONFIGURABLE_GRID_PARTITION \
49  ((D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE)6)
50 #endif
51 
52 #ifndef D3D12_VIDEO_ENCODER_AV1_INVALID_DPB_RESOURCE_INDEX
53 #define D3D12_VIDEO_ENCODER_AV1_INVALID_DPB_RESOURCE_INDEX ( 0xff )
54 #endif
55 
56 typedef struct D3D12VAHWBaseEncodeAV1 {
57  AV1RawOBU raw_sequence_header;
58  AV1RawOBU raw_frame_header;
59  AV1RawOBU raw_tile_group;
60 } D3D12VAHWBaseEncodeAV1;
61 
62 typedef struct D3D12VAHWBaseEncodeAV1Opts {
63  int tier; // 0: Main tier, 1: High tier
64  int level; // AV1 level (2.0-7.3 map to 0-23)
65 
66  int enable_cdef; // Constrained Directional Enhancement Filter
67  int enable_restoration; // loop restoration
68  int enable_superres; // super-resolution
69  int enable_ref_frame_mvs;
70 
71  int enable_jnt_comp;
72  int enable_128x128_superblock;
73 
74  int enable_warped_motion;
75  int enable_intra_edge_filter;
76  int enable_interintra_compound;
77  int enable_masked_compound;
78  int enable_filter_intra;
79 
80  int enable_loop_filter;
81  int enable_loop_filter_delta;
82  int enable_dual_filter;
83 
84  int enable_palette;
85  int enable_intra_block_copy;
86 } D3D12VAHWBaseEncodeAV1Opts;
87 
88 typedef struct D3D12VAEncodeAV1Picture {
89  uint8_t temporal_id;
90  uint8_t spatial_id;
91  uint8_t show_frame;
92  uint8_t frame_type;
93  uint16_t last_idr_frame;
94  uint8_t slot;
95 } D3D12VAEncodeAV1Picture;
96 
97 typedef struct D3D12VAEncodeAV1Context {
98  D3D12VAEncodeContext common;
99  // User options.
100  int qp;
101  int profile;
102  int level;
103  int tier;
104 
105  uint8_t q_idx_idr;
106  uint8_t q_idx_p;
107 
108  // Writer structures.
109  D3D12VAHWBaseEncodeAV1 units;
110  D3D12VAHWBaseEncodeAV1Opts unit_opts;
111 
112  CodedBitstreamContext *cbc;
113  CodedBitstreamFragment current_obu;
114  D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS post_encode_values_flag;
115  AVFifo *picture_header_list;
116 
117  int tile_cols;
118  int tile_rows;
119  int tile_cols_log2;
120  int tile_rows_log2;
121  int uniform_tile_spacing;
122  int tile_size_bytes;
123  uint16_t context_update_tile_id;
124  uint8_t width_in_sbs_minus_1[AV1_MAX_TILE_COLS];
125  uint8_t height_in_sbs_minus_1[AV1_MAX_TILE_ROWS];
126 } D3D12VAEncodeAV1Context;
127 
128 typedef struct D3D12VAEncodeAV1Level {
129  uint8_t level;
130  D3D12_VIDEO_ENCODER_AV1_LEVELS d3d12_level;
131 } D3D12VAEncodeAV1Level;
132 
133 static const D3D12VAEncodeAV1Level av1_levels[] = {
134  { 0, D3D12_VIDEO_ENCODER_AV1_LEVELS_2_0 },
135  { 1, D3D12_VIDEO_ENCODER_AV1_LEVELS_2_1 },
136  { 2, D3D12_VIDEO_ENCODER_AV1_LEVELS_2_2 },
137  { 3, D3D12_VIDEO_ENCODER_AV1_LEVELS_2_3 },
138  { 4, D3D12_VIDEO_ENCODER_AV1_LEVELS_3_0 },
139  { 5, D3D12_VIDEO_ENCODER_AV1_LEVELS_3_1 },
140  { 6, D3D12_VIDEO_ENCODER_AV1_LEVELS_3_2 },
141  { 7, D3D12_VIDEO_ENCODER_AV1_LEVELS_3_3 },
142  { 8, D3D12_VIDEO_ENCODER_AV1_LEVELS_4_0 },
143  { 9, D3D12_VIDEO_ENCODER_AV1_LEVELS_4_1 },
144  { 10, D3D12_VIDEO_ENCODER_AV1_LEVELS_4_2 },
145  { 11, D3D12_VIDEO_ENCODER_AV1_LEVELS_4_3 },
146  { 12, D3D12_VIDEO_ENCODER_AV1_LEVELS_5_0 },
147  { 13, D3D12_VIDEO_ENCODER_AV1_LEVELS_5_1 },
148  { 14, D3D12_VIDEO_ENCODER_AV1_LEVELS_5_2 },
149  { 15, D3D12_VIDEO_ENCODER_AV1_LEVELS_5_3 },
150  { 16, D3D12_VIDEO_ENCODER_AV1_LEVELS_6_0 },
151  { 17, D3D12_VIDEO_ENCODER_AV1_LEVELS_6_1 },
152  { 18, D3D12_VIDEO_ENCODER_AV1_LEVELS_6_2 },
153  { 19, D3D12_VIDEO_ENCODER_AV1_LEVELS_6_3 },
154  { 20, D3D12_VIDEO_ENCODER_AV1_LEVELS_7_0 },
155  { 21, D3D12_VIDEO_ENCODER_AV1_LEVELS_7_1 },
156  { 22, D3D12_VIDEO_ENCODER_AV1_LEVELS_7_2 },
157  { 23, D3D12_VIDEO_ENCODER_AV1_LEVELS_7_3 },
158 };
159 
160  typedef struct D3D12VAEncodeAV1TileInfo {
161  uint64_t full;
162  uint64_t prefix;
163  uint64_t data;
164 } D3D12VAEncodeAV1TileInfo;
165 
166 static const D3D12_VIDEO_ENCODER_AV1_PROFILE profile_main = D3D12_VIDEO_ENCODER_AV1_PROFILE_MAIN;
167 static const D3D12_VIDEO_ENCODER_AV1_PROFILE profile_high = D3D12_VIDEO_ENCODER_AV1_PROFILE_HIGH;
168 static const D3D12_VIDEO_ENCODER_AV1_PROFILE profile_professional = D3D12_VIDEO_ENCODER_AV1_PROFILE_PROFESSIONAL;
169 
170 #define D3D_PROFILE_DESC(name) \
171  { sizeof(D3D12_VIDEO_ENCODER_AV1_PROFILE), { .pAV1Profile = (D3D12_VIDEO_ENCODER_AV1_PROFILE *)&profile_ ## name } }
172 static const D3D12VAEncodeProfile d3d12va_encode_av1_profiles[] = {
173  { AV_PROFILE_AV1_MAIN, 8, 3, 1, 1, D3D_PROFILE_DESC(main) },
174  { AV_PROFILE_AV1_MAIN, 10, 3, 1, 1, D3D_PROFILE_DESC(main) },
175  { AV_PROFILE_AV1_HIGH, 10, 3, 1, 1, D3D_PROFILE_DESC(high) },
176  { AV_PROFILE_AV1_PROFESSIONAL, 8, 3, 1, 1, D3D_PROFILE_DESC(professional) },
177  { AV_PROFILE_AV1_PROFESSIONAL, 10, 3, 1, 1, D3D_PROFILE_DESC(professional) },
178  { AV_PROFILE_AV1_PROFESSIONAL, 12, 3, 1, 1, D3D_PROFILE_DESC(professional) },
179  { AV_PROFILE_UNKNOWN },
180 };
181 
182 static int d3d12va_encode_av1_write_obu(AVCodecContext *avctx,
183  char *data, size_t *data_len,
184  CodedBitstreamFragment *obu)
185 {
186  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
187  int err = 0;
188 
189  err = ff_cbs_write_fragment_data(priv->cbc, obu);
190  if (err < 0) {
191  av_log(avctx, AV_LOG_ERROR, "Failed to write packed OBU data.\n");
192  return err;
193  }
194 
195  memcpy(data, obu->data, obu->data_size);
196  *data_len = (8 * obu->data_size) - obu->data_bit_padding;
197 
198  return 0;
199 }
200 
201 static int d3d12va_encode_av1_add_obu(AVCodecContext* avctx,
202  CodedBitstreamFragment* au,
203  CodedBitstreamUnitType obu_type,
204  void* obu_unit)
205 {
206  int err = 0;
207 
208  err = ff_cbs_insert_unit_content(au, -1, obu_type, obu_unit, NULL);
209  if (err < 0) {
210  av_log(avctx, AV_LOG_ERROR, "Failed to add OBU unit: "
211  "type = %d.\n", obu_type);
212  return err;
213  }
214  return 0;
215 }
216 
217 static int d3d12va_encode_av1_write_sequence_header(AVCodecContext *avctx,
218  char *data, size_t *data_len)
219 {
220  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
221  CodedBitstreamFragment *obu = &priv->current_obu;
222  int err = 0;
223 
224  priv->units.raw_sequence_header.header.obu_type = AV1_OBU_SEQUENCE_HEADER;
225  err = d3d12va_encode_av1_add_obu(avctx, obu, AV1_OBU_SEQUENCE_HEADER, &priv->units.raw_sequence_header);
226  if (err < 0)
227  goto fail;
228 
229  err = d3d12va_encode_av1_write_obu(avctx, data, data_len, obu);
230 
231 fail:
232  ff_cbs_fragment_reset(obu);
233  return err;
234 }
235 
236 static int d3d12va_encode_av1_update_current_frame_picture_header(AVCodecContext *avctx,
237  D3D12VAEncodePicture *pic,
238  AV1RawOBU *frameheader_obu)
239 {
240  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
241  AV1RawFrameHeader *fh = &frameheader_obu->obu.frame_header;
242  uint8_t *data = NULL;
243  HRESULT hr = S_OK;
244  int err = 0;
245  D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES *post_encode_values = NULL;
246 
247  // Update the frame header according to the picture post_encode_values
248  hr = ID3D12Resource_Map(pic->resolved_metadata, 0, NULL, (void **)&data);
249  if (FAILED(hr)) {
250  err = AVERROR_UNKNOWN;
251  return err;
252  }
253  uint64_t nb_subregions = FFMAX(((D3D12_VIDEO_ENCODER_OUTPUT_METADATA *)data)->WrittenSubregionsCount, 1);
254  D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES *tile_partition =
255  (D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES *) (data +
256  sizeof(D3D12_VIDEO_ENCODER_OUTPUT_METADATA) +
257  sizeof(D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA) * nb_subregions);
258 
259  post_encode_values = (D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES *) (data +
260  sizeof(D3D12_VIDEO_ENCODER_OUTPUT_METADATA) +
261  sizeof(D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA) * nb_subregions +
262  sizeof(D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES));
263 
264  if (nb_subregions > 1)
265  fh->context_update_tile_id = tile_partition->ContextUpdateTileId;
266 
267  if (priv->post_encode_values_flag & D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_QUANTIZATION) {
268  fh->base_q_idx = post_encode_values->Quantization.BaseQIndex;
269  fh->delta_q_y_dc = post_encode_values->Quantization.YDCDeltaQ;
270  fh->delta_q_u_dc = post_encode_values->Quantization.UDCDeltaQ;
271  fh->delta_q_u_ac = post_encode_values->Quantization.UACDeltaQ;
272  fh->delta_q_v_dc = post_encode_values->Quantization.VDCDeltaQ;
273  fh->delta_q_v_ac = post_encode_values->Quantization.VACDeltaQ;
274  fh->using_qmatrix = post_encode_values->Quantization.UsingQMatrix;
275  fh->qm_y = post_encode_values->Quantization.QMY;
276  fh->qm_u = post_encode_values->Quantization.QMU;
277  fh->qm_v = post_encode_values->Quantization.QMV;
278  }
279 
280  if (priv->post_encode_values_flag & D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_LOOP_FILTER) {
281  fh->loop_filter_level[0] = post_encode_values->LoopFilter.LoopFilterLevel[0];
282  fh->loop_filter_level[1] = post_encode_values->LoopFilter.LoopFilterLevel[1];
283  fh->loop_filter_level[2] = post_encode_values->LoopFilter.LoopFilterLevelU;
284  fh->loop_filter_level[3] = post_encode_values->LoopFilter.LoopFilterLevelV;
285  fh->loop_filter_sharpness = post_encode_values->LoopFilter.LoopFilterSharpnessLevel;
286  fh->loop_filter_delta_enabled = post_encode_values->LoopFilter.LoopFilterDeltaEnabled;
287  if (fh->loop_filter_delta_enabled) {
288  for (int i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) {
289  fh->loop_filter_ref_deltas[i] = post_encode_values->LoopFilter.RefDeltas[i];
290  fh->update_ref_delta[i] = post_encode_values->LoopFilter.RefDeltas[i];
291  }
292  for (int i = 0; i < 2; i++) {
293  fh->loop_filter_mode_deltas[i] = post_encode_values->LoopFilter.ModeDeltas[i];
294  fh->update_mode_delta[i] = post_encode_values->LoopFilter.ModeDeltas[i];
295  }
296  }
297  }
298  if (priv->post_encode_values_flag & D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_CDEF_DATA) {
299  fh->cdef_damping_minus_3 = post_encode_values->CDEF.CdefDampingMinus3;
300  fh->cdef_bits = post_encode_values->CDEF.CdefBits;
301  for (int i = 0; i < 8; i++) {
302  fh->cdef_y_pri_strength[i] = post_encode_values->CDEF.CdefYPriStrength[i];
303  fh->cdef_y_sec_strength[i] = post_encode_values->CDEF.CdefYSecStrength[i];
304  fh->cdef_uv_pri_strength[i] = post_encode_values->CDEF.CdefUVPriStrength[i];
305  fh->cdef_uv_sec_strength[i] = post_encode_values->CDEF.CdefUVSecStrength[i];
306  }
307  }
308  if (priv->post_encode_values_flag & D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_QUANTIZATION_DELTA) {
309  fh->delta_q_present = post_encode_values->QuantizationDelta.DeltaQPresent;
310  fh->delta_q_res = post_encode_values->QuantizationDelta.DeltaQRes;
311  }
312 
313  if (priv->post_encode_values_flag & D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_REFERENCE_INDICES) {
314  for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
315  fh->ref_frame_idx[i] = post_encode_values->ReferenceIndices[i];
316  }
317  }
318 
319  ID3D12Resource_Unmap(pic->resolved_metadata, 0, NULL);
320  return 0;
321 }
322 
323 static int d3d12va_encode_av1_write_picture_header(AVCodecContext *avctx,
324  D3D12VAEncodePicture *pic,
325  char *data, size_t *data_len)
326 {
327  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
328  CodedBitstreamFragment *obu = &priv->current_obu;
329  AV1RawOBU *frameheader_obu = av_mallocz(sizeof(AV1RawOBU));
330  int err = 0;
331 
332  av_fifo_read(priv->picture_header_list, frameheader_obu, 1);
333  err = d3d12va_encode_av1_update_current_frame_picture_header(avctx, pic,frameheader_obu);
334  if (err < 0) {
335  av_log(avctx, AV_LOG_ERROR, "Failed to update current frame picture header: %d.\n", err);
336  return err;
337  }
338 
339  // Add the frame header OBU
340  frameheader_obu->header.obu_has_size_field = 1;
341 
342  err = d3d12va_encode_av1_add_obu(avctx, obu, AV1_OBU_FRAME_HEADER, frameheader_obu);
343  if (err < 0)
344  goto fail;
345  err = d3d12va_encode_av1_write_obu(avctx, data, data_len, obu);
346 
347 fail:
348  ff_cbs_fragment_reset(obu);
349  av_freep(&frameheader_obu);
350  return err;
351 }
352 
353 static int d3d12va_encode_av1_write_tile_group(AVCodecContext *avctx,
354  uint8_t* tile_group,
355  uint32_t tile_group_size,
356  char *data, size_t *data_len)
357 {
358  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
359  CodedBitstreamFragment *obu = &priv->current_obu;
360  AV1RawOBU *tile_group_obu = &priv->units.raw_tile_group;
361  AV1RawTileGroup *tg = &tile_group_obu->obu.tile_group;
362  int err = 0;
363 
364  tg->tile_start_and_end_present_flag = 0;
365  tg->tg_start = 0;
366  tg->tg_end = priv->tile_cols * priv->tile_rows - 1;
367 
368  tg->tile_data.data = tile_group;
369  tg->tile_data.data_ref = NULL;
370  tg->tile_data.data_size = tile_group_size;
371  tile_group_obu->header.obu_has_size_field = 1;
372  tile_group_obu->header.obu_type = AV1_OBU_TILE_GROUP;
373 
374  err = d3d12va_encode_av1_add_obu(avctx, obu, AV1_OBU_TILE_GROUP, tile_group_obu);
375  if (err < 0)
376  goto fail;
377  err = d3d12va_encode_av1_write_obu(avctx, data, data_len, obu);
378 
379 fail:
380  ff_cbs_fragment_reset(obu);
381  return err;
382 }
383 
384 static int d3d12va_encode_av1_get_buffer_size(AVCodecContext *avctx,
385  D3D12VAEncodePicture *pic,
386  uint64_t tile_size_bytes,
387  uint64_t *nb_subregions_out,
388  D3D12VAEncodeAV1TileInfo **tiles_out,
389  size_t *tile_payload_size_out)
390 {
391  uint8_t *meta_data = NULL;
392  HRESULT hr = S_OK;
393  int err = 0;
394 
395  D3D12_VIDEO_ENCODER_OUTPUT_METADATA *out;
396  D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA *subregions;
397  D3D12VAEncodeAV1TileInfo *tiles;
398  uint64_t nb_subregions;
399  size_t tile_payload_size = 0;
400 
401  hr = ID3D12Resource_Map(pic->resolved_metadata, 0, NULL, (void **)&meta_data);
402  if (FAILED(hr))
403  return AVERROR_EXTERNAL;
404 
405  out = (D3D12_VIDEO_ENCODER_OUTPUT_METADATA *)meta_data;
406  subregions = (D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA *) (meta_data +
407  sizeof(D3D12_VIDEO_ENCODER_OUTPUT_METADATA));
408 
409  if (out->EncodeErrorFlags != D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_NO_ERROR) {
410  av_log(avctx, AV_LOG_ERROR, "AV1 encode failed: error flags %#"PRIx64".\n",
411  (uint64_t)out->EncodeErrorFlags);
412  err = AVERROR_EXTERNAL;
413  goto unmap;
414  }
415 
416  nb_subregions = out->WrittenSubregionsCount;
417  if (nb_subregions == 0 || subregions[0].bSize == 0) {
418  av_log(avctx, AV_LOG_ERROR, "No subregion metadata found\n");
419  err = AVERROR(EINVAL);
420  goto unmap;
421  }
422 
423  tiles = av_malloc_array(nb_subregions, sizeof(*tiles));
424  if (!tiles) {
425  err = AVERROR(ENOMEM);
426  goto unmap;
427  }
428 
429  for (uint64_t i = 0; i < nb_subregions; i++) {
430  tiles[i].full = subregions[i].bSize;
431  tiles[i].prefix = subregions[i].bStartOffset;
432  tiles[i].data = subregions[i].bSize - subregions[i].bStartOffset;
433  tile_payload_size += tiles[i].data;
434  }
435  /* Every tile except the last is prefixed with a tile_size_minus_1 field. */
436  if (nb_subregions > 1)
437  tile_payload_size += (nb_subregions - 1) * tile_size_bytes;
438 
439  *nb_subregions_out = nb_subregions;
440  *tiles_out = tiles;
441  *tile_payload_size_out = tile_payload_size;
442 
443 unmap:
444  ID3D12Resource_Unmap(pic->resolved_metadata, 0, NULL);
445  return err;
446 }
447 
448 static int d3d12va_encode_av1_get_coded_data(AVCodecContext *avctx,
449  D3D12VAEncodePicture *pic, AVPacket *pkt)
450 {
451  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
452  int err = 0;
453  uint8_t *ptr = NULL;
454  uint8_t *mapped_data = NULL;
455  uint8_t *tile_group_buf = NULL;
456  char *obu_buf = NULL;
457  HRESULT hr = S_OK;
458  size_t av1_pic_hd_size = 0;
459  size_t bit_len = 0;
460  size_t obu_size = 0;
461  size_t tile_payload_size = 0;
462  size_t total_size = 0;
463  uint64_t nb_subregions = 0;
464  int output_buffer_mapped = 0;
465 
466  D3D12VAEncodeAV1TileInfo *tiles = NULL;
467  char pic_hd_data[MAX_PARAM_BUFFER_SIZE] = { 0 };
468 
469  err = d3d12va_encode_av1_get_buffer_size(avctx, pic, priv->tile_size_bytes,
470  &nb_subregions, &tiles,
471  &tile_payload_size);
472  if (err < 0)
473  goto end;
474 
475  hr = ID3D12Resource_Map(pic->output_buffer, 0, NULL, (void **)&mapped_data);
476  if (FAILED(hr)) {
477  err = AVERROR_UNKNOWN;
478  goto end;
479  }
480  output_buffer_mapped = 1;
481 
482  tile_group_buf = av_malloc(tile_payload_size);
483  if (!tile_group_buf) {
484  err = AVERROR(ENOMEM);
485  goto end;
486  }
487 
488  uint8_t *dst = tile_group_buf;
489  uint8_t *tiles_base = mapped_data + pic->aligned_header_size;
490  uint64_t src_off = 0;
491  for (uint64_t i = 0; i < nb_subregions; i++) {
492  /* Tiles are laid out contiguously by their full size; the actual
493  * tile data starts bStartOffset bytes into each subregion. */
494  uint64_t src_pos = src_off + tiles[i].prefix;
495  src_off += tiles[i].full;
496 
497  if (i != nb_subregions - 1) {
498  /* Write tile_size_minus_1 as a little-endian integer */
499  uint64_t v = tiles[i].data - 1;
500  for (uint64_t b = 0; b < priv->tile_size_bytes; b++)
501  *dst++ = (v >> (8 * b)) & 0xff;
502  }
503  memcpy(dst, tiles_base + src_pos, tiles[i].data);
504  dst += tiles[i].data;
505  }
506 
507  err = d3d12va_encode_av1_write_picture_header(avctx, pic, pic_hd_data, &bit_len);
508  if (err < 0) {
509  av_log(avctx, AV_LOG_ERROR, "Failed to write picture header: %d.\n", err);
510  goto end;
511  }
512  av1_pic_hd_size = bit_len / 8;
513 
514  obu_buf = av_malloc(tile_payload_size + MAX_PARAM_BUFFER_SIZE);
515  if (!obu_buf) {
516  err = AVERROR(ENOMEM);
517  goto end;
518  }
519  err = d3d12va_encode_av1_write_tile_group(avctx, tile_group_buf,
520  tile_payload_size, obu_buf, &bit_len);
521  if (err < 0) {
522  av_log(avctx, AV_LOG_ERROR, "Failed to write tile group: %d.\n", err);
523  goto end;
524  }
525  obu_size = bit_len / 8;
526 
527  total_size = pic->header_size + av1_pic_hd_size + obu_size;
528  err = ff_get_encode_buffer(avctx, pkt, total_size, 0);
529  if (err < 0)
530  goto end;
531  ptr = pkt->data;
532 
533  memcpy(ptr, mapped_data, pic->header_size);
534  ptr += pic->header_size;
535 
536  memcpy(ptr, pic_hd_data, av1_pic_hd_size);
537  ptr += av1_pic_hd_size;
538 
539  memcpy(ptr, obu_buf, obu_size);
540 
541  av_log(avctx, AV_LOG_DEBUG, "AV1 packet: %"PRIu64" tiles, header %d, "
542  "pic header %zu, tile group %zu, total %zu bytes.\n",
543  nb_subregions, pic->header_size, av1_pic_hd_size, obu_size, total_size);
544 
545 end:
546  if (output_buffer_mapped)
547  ID3D12Resource_Unmap(pic->output_buffer, 0, NULL);
548  av_freep(&tiles);
549  av_freep(&tile_group_buf);
550  av_freep(&obu_buf);
551  av_buffer_unref(&pic->output_buffer_ref);
552  pic->output_buffer = NULL;
553  return err;
554 }
555 
556 static int d3d12va_hw_base_encode_init_params_av1(FFHWBaseEncodeContext *base_ctx,
557  AVCodecContext *avctx,
558  D3D12VAHWBaseEncodeAV1 *common,
559  D3D12VAHWBaseEncodeAV1Opts *opts)
560 {
561  AV1RawOBU *seqheader_obu = &common->raw_sequence_header;
562  AV1RawSequenceHeader *seq = &seqheader_obu->obu.sequence_header;
563  const AVPixFmtDescriptor *desc;
564 
565  seq->seq_profile = avctx->profile;
566  if (!seq->seq_force_screen_content_tools)
567  seq->seq_force_integer_mv = AV1_SELECT_INTEGER_MV;
568  seq->seq_tier[0] = opts->tier;
569 
570  desc = av_pix_fmt_desc_get(base_ctx->input_frames->sw_format);
571  seq->color_config = (AV1RawColorConfig){
572  .high_bitdepth = desc->comp[0].depth == 8 ? 0 : 1,
573  .color_primaries = avctx->color_primaries,
574  .transfer_characteristics = avctx->color_trc,
575  .matrix_coefficients = avctx->colorspace,
576  .color_description_present_flag = (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
577  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
578  avctx->colorspace != AVCOL_SPC_UNSPECIFIED),
579  .color_range = avctx->color_range == AVCOL_RANGE_JPEG,
580  .subsampling_x = desc->log2_chroma_w,
581  .subsampling_y = desc->log2_chroma_h,
582  };
583 
584  switch (avctx->chroma_sample_location) {
585  case AVCHROMA_LOC_LEFT:
586  seq->color_config.chroma_sample_position = AV1_CSP_VERTICAL;
587  break;
588  case AVCHROMA_LOC_TOPLEFT:
589  seq->color_config.chroma_sample_position = AV1_CSP_COLOCATED;
590  break;
591  default:
592  seq->color_config.chroma_sample_position = AV1_CSP_UNKNOWN;
593  break;
594  }
595 
596  if (avctx->level != AV_LEVEL_UNKNOWN) {
597  seq->seq_level_idx[0] = avctx->level;
598  }
599  else {
600  const AV1LevelDescriptor *level;
601  float framerate;
602 
603  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
604  framerate = avctx->framerate.num / avctx->framerate.den;
605  else
606  framerate = 0;
607 
608  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
609  int tile_cols = priv->tile_cols > 0 ? priv->tile_cols : 1;
610  int tile_rows = priv->tile_rows > 0 ? priv->tile_rows : 1;
611 
612  level = ff_av1_guess_level(avctx->bit_rate, opts->tier,
613  base_ctx->surface_width, base_ctx->surface_height,
614  tile_rows * tile_cols, tile_cols, framerate);
615  if (level) {
616  av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
617  seq->seq_level_idx[0] = level->level_idx;
618  }
619  else {
620  av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
621  "any normal level, using maximum parameters level by default.\n");
622  seq->seq_level_idx[0] = 31;
623  seq->seq_tier[0] = 1;
624  }
625  }
626 
627  // Still picture mode
628  seq->still_picture = (base_ctx->gop_size == 1);
629  seq->reduced_still_picture_header = seq->still_picture;
630 
631  // Feature flags
632  seq->use_128x128_superblock = opts->enable_128x128_superblock;
633  seq->enable_filter_intra = opts->enable_filter_intra;
634  seq->enable_intra_edge_filter = opts->enable_intra_edge_filter;
635  seq->enable_interintra_compound = opts->enable_interintra_compound;
636  seq->enable_masked_compound = opts->enable_masked_compound;
637  seq->enable_warped_motion = opts->enable_warped_motion;
638  seq->enable_dual_filter = opts->enable_dual_filter;
639  seq->enable_order_hint = !seq->still_picture;
640  if (seq->enable_order_hint) {
641  seq->order_hint_bits_minus_1 = 7;
642  }
643  seq->enable_jnt_comp = opts->enable_jnt_comp && seq->enable_order_hint;
644  seq->enable_ref_frame_mvs = opts->enable_ref_frame_mvs && seq->enable_order_hint;
645  seq->enable_superres = opts->enable_superres;
646  seq->enable_cdef = opts->enable_cdef;
647  seq->enable_restoration = opts->enable_restoration;
648 
649  return 0;
650 
651 }
652 
653 static int d3d12va_encode_av1_init_sequence_params(AVCodecContext *avctx)
654 {
655  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
656  D3D12VAEncodeContext *ctx = avctx->priv_data;
657  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
658  AVD3D12VAFramesContext *hwctx = base_ctx->input_frames->hwctx;
659  AV1RawOBU *seqheader_obu = &priv->units.raw_sequence_header;
660  AV1RawSequenceHeader *seq = &priv->units.raw_sequence_header.obu.sequence_header;
661 
662  D3D12_VIDEO_ENCODER_AV1_PROFILE profile = D3D12_VIDEO_ENCODER_AV1_PROFILE_MAIN;
663  D3D12_VIDEO_ENCODER_AV1_LEVEL_TIER_CONSTRAINTS level = { 0 };
664  HRESULT hr;
665  int err;
666 
667  D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT1 support = {
668  .NodeIndex = 0,
669  .Codec = D3D12_VIDEO_ENCODER_CODEC_AV1,
670  .InputFormat = hwctx->format,
671  .RateControl = ctx->rc,
672  .IntraRefresh = ctx->intra_refresh.Mode,
673  .SubregionFrameEncoding = ctx->subregion_mode,
674  .ResolutionsListCount = 1,
675  .pResolutionList = &ctx->resolution,
676  .CodecGopSequence = ctx->gop,
677  .MaxReferenceFramesInDPB = AV1_NUM_REF_FRAMES,
678  .CodecConfiguration = ctx->codec_conf,
679  .SuggestedProfile.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_PROFILE),
680  .SuggestedProfile.pAV1Profile = &profile,
681  .SuggestedLevel.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_LEVEL_TIER_CONSTRAINTS),
682  .SuggestedLevel.pAV1LevelSetting = &level,
683  .pResolutionDependentSupport = &ctx->res_limits,
684  .SubregionFrameEncodingData.pTilesPartition_AV1 = ctx->subregions_layout.pTilesPartition_AV1,
685  };
686 
687  hr = ID3D12VideoDevice3_CheckFeatureSupport(ctx->video_device3, D3D12_FEATURE_VIDEO_ENCODER_SUPPORT1,
688  &support, sizeof(support));
689 
690  if (FAILED(hr)) {
691  av_log(avctx, AV_LOG_ERROR, "Failed to check encoder support(%lx).\n", (long)hr);
692  return AVERROR(EINVAL);
693  }
694 
695  if (!(support.SupportFlags & D3D12_VIDEO_ENCODER_SUPPORT_FLAG_GENERAL_SUPPORT_OK)) {
696  av_log(avctx, AV_LOG_ERROR, "Driver does not support requested features. ValidationFlags: %#x\n",
697  support.ValidationFlags);
698  ff_d3d12va_encode_check_encoder_feature_flags(avctx, support.ValidationFlags);
699  return AVERROR(EINVAL);
700  }
701 
702  if (support.SupportFlags & D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RECONSTRUCTED_FRAMES_REQUIRE_TEXTURE_ARRAYS) {
703  ctx->is_texture_array = 1;
704  av_log(avctx, AV_LOG_DEBUG, "D3D12 video encode on this device uses texture array mode.\n");
705  }
706 
707  // Check if the configuration with DELTA_QP is supported
708  if (support.SupportFlags & D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_DELTA_QP_AVAILABLE) {
709  base_ctx->roi_allowed = 1;
710  // Store the QP map region size from resolution limits
711  ctx->qp_map_region_size = ctx->res_limits.QPMapRegionPixelsSize;
712  av_log(avctx, AV_LOG_DEBUG, "ROI encoding is supported via delta QP "
713  "(QP map region size: %d pixels).\n", ctx->qp_map_region_size);
714  } else {
715  base_ctx->roi_allowed = 0;
716  av_log(avctx, AV_LOG_DEBUG, "ROI encoding not supported by hardware for current rate control mode \n");
717  }
718 
719  // Check motion estimation precision mode support
720  if (ctx->me_precision != D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM) {
721  if (!(support.SupportFlags & D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE)) {
722  av_log(avctx, AV_LOG_ERROR, "Hardware does not support motion estimation "
723  "precision mode limits.\n");
724  return AVERROR(ENOTSUP);
725  }
726  av_log(avctx, AV_LOG_VERBOSE, "Hardware supports motion estimation "
727  "precision mode limits.\n");
728  }
729 
730  memset(seqheader_obu, 0, sizeof(*seqheader_obu));
731  seq->seq_profile = profile;
732  seq->seq_level_idx[0] = level.Level;
733  seq->seq_tier[0] = level.Tier;
734 
735  seq->max_frame_width_minus_1 = ctx->resolution.Width - 1;
736  seq->max_frame_height_minus_1 = ctx->resolution.Height - 1;
737  seq->frame_width_bits_minus_1 = av_log2(ctx->resolution.Width);
738  seq->frame_height_bits_minus_1 = av_log2(ctx->resolution.Height);
739 
740  seqheader_obu->header.obu_type = AV1_OBU_SEQUENCE_HEADER;
741 
742  err = d3d12va_hw_base_encode_init_params_av1(base_ctx, avctx,
743  &priv->units, &priv->unit_opts);
744  if (err < 0)
745  return err;
746 
747  if (avctx->level == AV_LEVEL_UNKNOWN)
748  avctx->level = level.Level;
749 
750  return 0;
751 }
752 
753 static av_always_inline int d3d12va_encode_av1_tile_log2(int blksize, int target)
754 {
755  int k;
756  for (k = 0; (blksize << k) < target; k++);
757  return k;
758 }
759 
760 static int d3d12va_encode_av1_set_tile(AVCodecContext *avctx)
761 {
762  D3D12VAEncodeContext *ctx = avctx->priv_data;
763  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
764  D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES *tiles_layout;
765 
766  ctx->subregions_layout.DataSize =
767  sizeof(D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES);
768  tiles_layout = av_mallocz(ctx->subregions_layout.DataSize);
769  if (!tiles_layout)
770  return AVERROR(ENOMEM);
771  ctx->subregions_layout.pTilesPartition_AV1 = tiles_layout;
772 
773  int use_128 = priv->unit_opts.enable_128x128_superblock;
774  int width = ctx->resolution.Width;
775  int height = ctx->resolution.Height;
776 
777  int mi_cols = 2 * ((width + 7) >> 3);
778  int mi_rows = 2 * ((height + 7) >> 3);
779  int sb_cols = use_128 ? ((mi_cols + 31) >> 5) : ((mi_cols + 15) >> 4);
780  int sb_rows = use_128 ? ((mi_rows + 31) >> 5) : ((mi_rows + 15) >> 4);
781  int sb_shift = use_128 ? 5 : 4;
782  int sb_size = sb_shift + 2;
783 
784  int max_tile_width_sb = AV1_MAX_TILE_WIDTH >> sb_size;
785  int max_tile_area_sb = AV1_MAX_TILE_AREA >> (2 * sb_size);
786 
787  int min_log2_tile_cols = d3d12va_encode_av1_tile_log2(max_tile_width_sb, sb_cols);
788  int min_log2_tiles = FFMAX(min_log2_tile_cols,
789  d3d12va_encode_av1_tile_log2(max_tile_area_sb, sb_rows * sb_cols));
790  int max_tile_area_sb_varied;
791  int tile_width_sb, tile_height_sb, widest_tile_sb;
792  int tile_cols, tile_rows;
793  int min_tile_cols = (sb_cols + max_tile_width_sb - 1) / max_tile_width_sb;
794  int i;
795 
796  if (priv->tile_cols > AV1_MAX_TILE_COLS ||
797  priv->tile_rows > AV1_MAX_TILE_ROWS) {
798  av_log(avctx, AV_LOG_ERROR, "Invalid tile number %dx%d, should be at "
799  "most %dx%d.\n", priv->tile_cols, priv->tile_rows,
800  AV1_MAX_TILE_COLS, AV1_MAX_TILE_ROWS);
801  return AVERROR(EINVAL);
802  }
803 
804  /* Calculate tile columns. When the user did not set tile explicitly
805  * (tile_cols == 0) this fallback to the minimum valid number */
806  tile_cols = av_clip(priv->tile_cols, min_tile_cols, sb_cols);
807  if (!priv->tile_cols)
808  priv->tile_cols = tile_cols;
809  else if (priv->tile_cols != tile_cols) {
810  av_log(avctx, AV_LOG_ERROR, "Invalid tile cols %d, should be in range "
811  "of %d~%d.\n", priv->tile_cols, min_tile_cols, sb_cols);
812  return AVERROR(EINVAL);
813  }
814 
815  priv->tile_cols_log2 = d3d12va_encode_av1_tile_log2(1, priv->tile_cols);
816  tile_width_sb = (sb_cols + (1 << priv->tile_cols_log2) - 1) >> priv->tile_cols_log2;
817 
818  if (priv->tile_rows > sb_rows) {
819  av_log(avctx, AV_LOG_ERROR, "Invalid tile rows %d, should be less than "
820  "%d.\n", priv->tile_rows, sb_rows);
821  return AVERROR(EINVAL);
822  }
823 
824  tile_rows = priv->tile_rows ? priv->tile_rows : 1;
825  for (; tile_rows <= sb_rows && tile_rows <= AV1_MAX_TILE_ROWS; tile_rows++) {
826  /* try uniformed tile first. */
827  priv->tile_rows_log2 = d3d12va_encode_av1_tile_log2(1, tile_rows);
828 
829  if ((sb_cols + tile_width_sb - 1) / tile_width_sb == priv->tile_cols) {
830  for (i = 0; i < priv->tile_cols - 1; i++)
831  priv->width_in_sbs_minus_1[i] = tile_width_sb - 1;
832  priv->width_in_sbs_minus_1[i] = sb_cols - (priv->tile_cols - 1) * tile_width_sb - 1;
833 
834  tile_height_sb = (sb_rows + (1 << priv->tile_rows_log2) - 1) >>
835  priv->tile_rows_log2;
836 
837  if ((sb_rows + tile_height_sb - 1) / tile_height_sb == tile_rows &&
838  tile_height_sb <= max_tile_area_sb / tile_width_sb) {
839  for (i = 0; i < tile_rows - 1; i++)
840  priv->height_in_sbs_minus_1[i] = tile_height_sb - 1;
841  priv->height_in_sbs_minus_1[i] = sb_rows - (tile_rows - 1) * tile_height_sb - 1;
842 
843  priv->uniform_tile_spacing = 1;
844  break;
845  }
846  }
847 
848  /* Try non-uniform fallback: distribute columns/rows as evenly as possible */
849  widest_tile_sb = 0;
850  for (i = 0; i < priv->tile_cols; i++) {
851  priv->width_in_sbs_minus_1[i] =
852  (i + 1) * sb_cols / priv->tile_cols - i * sb_cols / priv->tile_cols - 1;
853  widest_tile_sb = FFMAX(widest_tile_sb, priv->width_in_sbs_minus_1[i] + 1);
854  }
855 
856  if (min_log2_tiles)
857  max_tile_area_sb_varied = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
858  else
859  max_tile_area_sb_varied = sb_rows * sb_cols;
860  tile_height_sb = FFMAX(1, max_tile_area_sb_varied / widest_tile_sb);
861 
862  if (tile_rows == av_clip(tile_rows,
863  (sb_rows + tile_height_sb - 1) / tile_height_sb,
864  sb_rows)) {
865  for (i = 0; i < tile_rows; i++)
866  priv->height_in_sbs_minus_1[i] =
867  (i + 1) * sb_rows / tile_rows - i * sb_rows / tile_rows - 1;
868 
869  priv->uniform_tile_spacing = 0;
870  break;
871  }
872 
873  if (priv->tile_rows) {
874  av_log(avctx, AV_LOG_ERROR, "Invalid tile rows %d.\n", priv->tile_rows);
875  return AVERROR(EINVAL);
876  }
877  }
878 
879  priv->tile_rows = tile_rows;
880  av_log(avctx, AV_LOG_DEBUG, "Setting tile cols/rows to %d/%d.\n",
881  priv->tile_cols, priv->tile_rows);
882 
883  if (priv->tile_cols > AV1_MAX_TILE_COLS || priv->tile_rows > AV1_MAX_TILE_ROWS) {
884  av_log(avctx, AV_LOG_ERROR, "Resolution %dx%d requires %dx%d tiles which "
885  "exceeds the AV1 maximum of %dx%d.\n", width, height,
886  priv->tile_cols, priv->tile_rows, AV1_MAX_TILE_COLS, AV1_MAX_TILE_ROWS);
887  return AVERROR(EINVAL);
888  }
889 
890  priv->context_update_tile_id = priv->tile_cols * priv->tile_rows - 1;
891  priv->tile_size_bytes = 4;
892 
893  tiles_layout->RowCount = priv->tile_rows;
894  tiles_layout->ColCount = priv->tile_cols;
895  for (i = 0; i < priv->tile_cols; i++)
896  tiles_layout->ColWidths[i] = priv->width_in_sbs_minus_1[i] + 1;
897  for (i = 0; i < priv->tile_rows; i++)
898  tiles_layout->RowHeights[i] = priv->height_in_sbs_minus_1[i] + 1;
899  tiles_layout->ContextUpdateTileId = priv->context_update_tile_id;
900 
901  ctx->num_subregions = priv->tile_cols * priv->tile_rows;
902 
903  if (ctx->num_subregions <= 1)
904  ctx->subregion_mode = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_FULL_FRAME;
905  else if (priv->uniform_tile_spacing)
906  ctx->subregion_mode = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_GRID_PARTITION;
907  else
908  ctx->subregion_mode = D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_CONFIGURABLE_GRID_PARTITION;
909 
910  av_log(avctx, AV_LOG_VERBOSE, "AV1 tile partition: %d cols x %d rows "
911  "(%s superblocks, %s).\n", priv->tile_cols, priv->tile_rows,
912  use_128 ? "128x128" : "64x64",
913  ctx->num_subregions <= 1 ? "full frame" :
914  priv->uniform_tile_spacing ? "uniform grid" : "configurable grid");
915 
916  return 0;
917 }
918 
919 static int d3d12va_encode_av1_get_encoder_caps(AVCodecContext *avctx)
920 {
921  HRESULT hr = S_OK;
922  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
923  D3D12VAEncodeContext *ctx = avctx->priv_data;
924  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
925 
926  D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION *config;
927  D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION_SUPPORT av1_caps;
928 
929  D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT codec_caps = {
930  .NodeIndex = 0,
931  .Codec = D3D12_VIDEO_ENCODER_CODEC_AV1,
932  .Profile = ctx->profile->d3d12_profile,
933  .CodecSupportLimits.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION_SUPPORT),
934  };
935 
936  codec_caps.CodecSupportLimits.pAV1Support = &av1_caps;
937 
938  hr = ID3D12VideoDevice3_CheckFeatureSupport(ctx->video_device3, D3D12_FEATURE_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT,
939  &codec_caps, sizeof(codec_caps));
940  if (!(SUCCEEDED(hr) && codec_caps.IsSupported))
941  return AVERROR(EINVAL);
942 
943  ctx->codec_conf.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION);
944  ctx->codec_conf.pAV1Config = av_mallocz(ctx->codec_conf.DataSize);
945  if (!ctx->codec_conf.pAV1Config)
946  return AVERROR(ENOMEM);
947 
948  priv->post_encode_values_flag = av1_caps.PostEncodeValuesFlags;
949  config = ctx->codec_conf.pAV1Config;
950 
951  config->FeatureFlags = D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_NONE;
952  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_128x128_SUPERBLOCK) {
953  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_128x128_SUPERBLOCK;
954  priv->unit_opts.enable_128x128_superblock = 1;
955  }
956 
957  base_ctx->surface_width = FFALIGN(avctx->width, priv->unit_opts.enable_128x128_superblock ? 128 : 64);
958  base_ctx->surface_height = FFALIGN(avctx->height, priv->unit_opts.enable_128x128_superblock ? 128 : 64);
959 
960  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_LOOP_RESTORATION_FILTER) {
961  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_LOOP_RESTORATION_FILTER;
962  priv->unit_opts.enable_loop_filter = 1;
963  }
964 
965  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_PALETTE_ENCODING) {
966  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_PALETTE_ENCODING;
967  priv->unit_opts.enable_palette = 1;
968  }
969 
970  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTRA_BLOCK_COPY) {
971  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTRA_BLOCK_COPY;
972  priv->unit_opts.enable_intra_block_copy = 1;
973  }
974 
975  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_LOOP_FILTER_DELTAS) {
976  // Loop filter deltas
977  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_LOOP_FILTER_DELTAS;
978  priv->unit_opts.enable_loop_filter_delta = 1;
979  }
980 
981  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_CDEF_FILTERING) {
982  // CDEF (Constrained Directional Enhancement Filter)
983  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_CDEF_FILTERING;
984  priv->unit_opts.enable_cdef = 1;
985  }
986 
987  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_DUAL_FILTER) {
988  // Dual filter
989  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_DUAL_FILTER;
990  priv->unit_opts.enable_dual_filter = 1;
991  }
992 
993  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_JNT_COMP) {
994  // Joint compound prediction
995  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_JNT_COMP;
996  priv->unit_opts.enable_jnt_comp = 1;
997  }
998 
999  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_FRAME_REFERENCE_MOTION_VECTORS) {
1000  // Frame reference motion vectors
1001  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_FRAME_REFERENCE_MOTION_VECTORS;
1002  priv->unit_opts.enable_ref_frame_mvs = 1;
1003  }
1004 
1005  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_SUPER_RESOLUTION) {
1006  // Super-resolution
1007  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_SUPER_RESOLUTION;
1008  priv->unit_opts.enable_superres = 1;
1009  }
1010 
1011  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_WARPED_MOTION) {
1012  // Warped motion
1013  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_WARPED_MOTION;
1014  priv->unit_opts.enable_warped_motion = 1;
1015  }
1016 
1017  if (av1_caps.SupportedFeatureFlags & D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTERINTRA_COMPOUND) {
1018  // Inter-intra compound prediction
1019  config->FeatureFlags |= D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTERINTRA_COMPOUND;
1020  priv->unit_opts.enable_interintra_compound = 1;
1021  }
1022 
1023  return 0;
1024 }
1025 
1026 static int d3d12va_encode_av1_configure(AVCodecContext *avctx)
1027 {
1028  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
1029  D3D12VAEncodeContext *ctx = avctx->priv_data;
1030  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
1031  int err = 0;
1032  int fixed_qp_key, fixed_qp_inter;
1033 
1034  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_AV1, avctx);
1035  if (err < 0)
1036  return err;
1037 
1038  if (ctx->rc.Mode == D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP) {
1039  D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP *cqp_ctl;
1040  fixed_qp_inter = av_clip_uintp2(ctx->rc_quality, 8);
1041 
1042  if (avctx->i_quant_factor > 0.0)
1043  fixed_qp_key = av_clip_uintp2((avctx->i_quant_factor * fixed_qp_inter +
1044  avctx->i_quant_offset) + 0.5, 8);
1045  else
1046  fixed_qp_key = fixed_qp_inter;
1047 
1048  av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1049  "%d / %d for Key / Inter frames.\n",
1050  fixed_qp_key, fixed_qp_inter);
1051 
1052  ctx->rc.ConfigParams.DataSize = sizeof(D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP);
1053  cqp_ctl = av_mallocz(ctx->rc.ConfigParams.DataSize);
1054  if (!cqp_ctl)
1055  return AVERROR(ENOMEM);
1056 
1057  cqp_ctl->ConstantQP_FullIntracodedFrame = fixed_qp_key;
1058  cqp_ctl->ConstantQP_InterPredictedFrame_PrevRefOnly = fixed_qp_inter;
1059  cqp_ctl->ConstantQP_InterPredictedFrame_BiDirectionalRef = fixed_qp_inter;
1060 
1061  ctx->rc.ConfigParams.pConfiguration_CQP = cqp_ctl;
1062 
1063  priv->q_idx_idr = fixed_qp_key;
1064  priv->q_idx_p = fixed_qp_inter;
1065 
1066  }
1067 
1068  // GOP configuration for AV1
1069  ctx->gop.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_SEQUENCE_STRUCTURE);
1070  ctx->gop.pAV1SequenceStructure = av_mallocz(ctx->gop.DataSize);
1071  if (!ctx->gop.pAV1SequenceStructure)
1072  return AVERROR(ENOMEM);
1073 
1074  ctx->gop.pAV1SequenceStructure->IntraDistance = base_ctx->gop_size;
1075  ctx->gop.pAV1SequenceStructure->InterFramePeriod = base_ctx->b_per_p + 1;
1076 
1077  return 0;
1078 }
1079 
1080 static int d3d12va_encode_av1_set_level(AVCodecContext *avctx)
1081 {
1082  D3D12VAEncodeContext *ctx = avctx->priv_data;
1083  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
1084  int i = 0;
1085 
1086  ctx->level.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_LEVEL_TIER_CONSTRAINTS);
1087  ctx->level.pAV1LevelSetting = av_mallocz(ctx->level.DataSize);
1088  if (!ctx->level.pAV1LevelSetting)
1089  return AVERROR(ENOMEM);
1090 
1091  if (avctx->level != AV_LEVEL_UNKNOWN) {
1092  for (i = 0; i < FF_ARRAY_ELEMS(av1_levels); i++) {
1093  if (avctx->level == av1_levels[i].level) {
1094  ctx->level.pAV1LevelSetting->Level = av1_levels[i].d3d12_level;
1095  break;
1096  }
1097  }
1098 
1099  if (i == FF_ARRAY_ELEMS(av1_levels) ) {
1100  av_log(avctx, AV_LOG_ERROR, "Invalid AV1 level %d.\n", avctx->level);
1101  return AVERROR(EINVAL);
1102  }
1103  } else {
1104  ctx->level.pAV1LevelSetting->Level = D3D12_VIDEO_ENCODER_AV1_LEVELS_5_2;
1105  avctx->level = D3D12_VIDEO_ENCODER_AV1_LEVELS_5_2;
1106  av_log(avctx, AV_LOG_DEBUG, "Using default AV1 level 5.2\n");
1107  }
1108 
1109  if (priv->tier == 1 || avctx->bit_rate > 30000000) {
1110  ctx->level.pAV1LevelSetting->Tier = D3D12_VIDEO_ENCODER_AV1_TIER_HIGH;
1111  av_log(avctx, AV_LOG_DEBUG, "Using AV1 High tier\n");
1112  } else {
1113  ctx->level.pAV1LevelSetting->Tier = D3D12_VIDEO_ENCODER_AV1_TIER_MAIN;
1114  av_log(avctx, AV_LOG_DEBUG, "Using AV1 Main tier\n");
1115  }
1116 
1117  if (priv->tier >= 0) {
1118  ctx->level.pAV1LevelSetting->Tier = priv->tier == 0 ?
1119  D3D12_VIDEO_ENCODER_AV1_TIER_MAIN :
1120  D3D12_VIDEO_ENCODER_AV1_TIER_HIGH;
1121  }
1122 
1123  av_log(avctx, AV_LOG_DEBUG, "AV1 level set to %d, tier: %s\n",
1124  ctx->level.pAV1LevelSetting->Level,
1125  ctx->level.pAV1LevelSetting->Tier == D3D12_VIDEO_ENCODER_AV1_TIER_MAIN ? "Main" : "High");
1126 
1127  return 0;
1128 }
1129 
1130 static void d3d12va_encode_av1_free_picture_params(D3D12VAEncodePicture *pic)
1131 {
1132  if (!pic->pic_ctl.pAV1PicData)
1133  return;
1134 
1135  av_freep(&pic->pic_ctl.pAV1PicData);
1136 }
1137 
1138 static int d3d12va_encode_av1_init_picture_params(AVCodecContext *avctx,
1139  FFHWBaseEncodePicture *pic)
1140 {
1141  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
1142  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
1143  D3D12VAEncodeContext *ctx = avctx->priv_data;
1144  D3D12VAEncodePicture *d3d12va_pic = pic->priv;
1145  D3D12VAEncodeAV1Picture *hpic = pic->codec_priv;
1146  CodedBitstreamAV1Context *cbctx = priv->cbc->priv_data;
1147  AV1RawOBU *frameheader_obu = &priv->units.raw_frame_header;
1148  AV1RawFrameHeader *fh = &frameheader_obu->obu.frame_header;
1149 
1150  FFHWBaseEncodePicture *ref;
1151  D3D12VAEncodeAV1Picture *href;
1152  int i;
1153 
1154  static const int8_t default_loop_filter_ref_deltas[AV1_TOTAL_REFS_PER_FRAME] =
1155  { 1, 0, 0, 0, -1, 0, -1, -1 };
1156 
1157  memset(frameheader_obu, 0, sizeof(*frameheader_obu));
1158 
1159  frameheader_obu->header.obu_type = AV1_OBU_FRAME_HEADER;
1160 
1161  d3d12va_pic->pic_ctl.DataSize = sizeof(D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_CODEC_DATA);
1162  d3d12va_pic->pic_ctl.pAV1PicData = av_mallocz(d3d12va_pic->pic_ctl.DataSize);
1163  if (!d3d12va_pic->pic_ctl.pAV1PicData)
1164  return AVERROR(ENOMEM);
1165 
1166  // Initialize frame type and reference frame management
1167  switch(pic->type) {
1168  case FF_HW_PICTURE_TYPE_IDR:
1169  fh->frame_type = AV1_FRAME_KEY;
1170  fh->refresh_frame_flags = 0xFF;
1171  fh->base_q_idx = priv->q_idx_idr;
1172  hpic->slot = 0;
1173  hpic->last_idr_frame = pic->display_order;
1174  fh->tx_mode = AV1_TX_MODE_LARGEST;
1175  break;
1176 
1177  case FF_HW_PICTURE_TYPE_P:
1178  fh->frame_type = AV1_FRAME_INTER;
1179  fh->base_q_idx = priv->q_idx_p;
1180  fh->tx_mode = AV1_TX_MODE_SELECT;
1181 
1182  ref = pic->refs[0][pic->nb_refs[0] - 1];
1183  href = ref->codec_priv;
1184 
1185  /**
1186  * The encoder uses a simple alternating reference frame strategy:
1187  * - For P-frames, it uses the last reconstructed frame as a reference.
1188  * - To simplify the reference model of the encoder, the encoder alternates between
1189  * two reference frame slots (typically slot 0 and slot 1) for storing reconstructed
1190  * images and providing prediction references for the next frame.
1191  */
1192  if (base_ctx->ref_l0 > 1) {
1193  hpic->slot = !href->slot;
1194  } else {
1195  hpic->slot = 0;
1196  }
1197  hpic->last_idr_frame = href->last_idr_frame;
1198  fh->refresh_frame_flags = 1 << hpic->slot;
1199 
1200  // Set the nearest frame in L0 as all reference frame.
1201  for (i = 0; i < AV1_REFS_PER_FRAME; i++)
1202  fh->ref_frame_idx[i] = href->slot;
1203 
1204  fh->primary_ref_frame = href->slot;
1205  fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame;
1206 
1207  // Set the 2nd nearest frame in L0 as Golden frame.
1208  if (pic->nb_refs[0] > 1) {
1209  ref = pic->refs[0][pic->nb_refs[0] - 2];
1210  href = ref->codec_priv;
1211  // Reference frame index 3 is the GOLDEN_FRAME
1212  fh->ref_frame_idx[3] = href->slot;
1213  fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame;
1214  } else if (base_ctx->ref_l0 == 1) {
1215  fh->ref_order_hint[!href->slot] = cbctx->ref[!href->slot].order_hint;
1216  }
1217  break;
1218 
1219  case FF_HW_PICTURE_TYPE_B:
1220  av_log(avctx, AV_LOG_ERROR, "D3D12 AV1 video encode on this device requires B-frame support, "
1221  "but it's not implemented.\n");
1222  return AVERROR_PATCHWELCOME;
1223  default:
1224  av_log(avctx, AV_LOG_ERROR, "Unsupported picture type %d.\n", pic->type);
1225  }
1226 
1227 
1228  cbctx->seen_frame_header = 0;
1229 
1230  fh->show_frame = pic->display_order <= pic->encode_order;
1231  fh->showable_frame = fh->frame_type != AV1_FRAME_KEY;
1232  fh->order_hint = pic->display_order - hpic->last_idr_frame;
1233  fh->frame_width_minus_1 = ctx->resolution.Width - 1;
1234  fh->frame_height_minus_1 = ctx->resolution.Height - 1;
1235  fh->render_width_minus_1 = fh->frame_width_minus_1;
1236  fh->render_height_minus_1 = fh->frame_height_minus_1;
1237  fh->is_filter_switchable = 1;
1238  fh->interpolation_filter = AV1_INTERPOLATION_FILTER_SWITCHABLE;
1239 
1240  fh->uniform_tile_spacing_flag = priv->uniform_tile_spacing;
1241  fh->tile_cols = priv->tile_cols;
1242  fh->tile_rows = priv->tile_rows;
1243  fh->tile_cols_log2 = priv->tile_cols_log2;
1244  fh->tile_rows_log2 = priv->tile_rows_log2;
1245  fh->context_update_tile_id = priv->context_update_tile_id;
1246  fh->tile_size_bytes_minus1 = priv->tile_size_bytes - 1;
1247  for (i = 0; i < priv->tile_cols; i++)
1248  fh->width_in_sbs_minus_1[i] = priv->width_in_sbs_minus_1[i];
1249  for (i = 0; i < priv->tile_rows; i++)
1250  fh->height_in_sbs_minus_1[i] = priv->height_in_sbs_minus_1[i];
1251 
1252  memcpy(fh->loop_filter_ref_deltas, default_loop_filter_ref_deltas,
1253  AV1_TOTAL_REFS_PER_FRAME * sizeof(int8_t));
1254 
1255  if (fh->frame_type == AV1_FRAME_KEY && fh->show_frame)
1256  fh->error_resilient_mode = 1;
1257 
1258  if (fh->frame_type == AV1_FRAME_KEY || fh->error_resilient_mode)
1259  fh->primary_ref_frame = AV1_PRIMARY_REF_NONE;
1260 
1261  d3d12va_pic->pic_ctl.pAV1PicData->FrameType = fh->frame_type;
1262  d3d12va_pic->pic_ctl.pAV1PicData->TxMode = fh->tx_mode;
1263  d3d12va_pic->pic_ctl.pAV1PicData->RefreshFrameFlags = fh->refresh_frame_flags;
1264  d3d12va_pic->pic_ctl.pAV1PicData->TemporalLayerIndexPlus1 = hpic->temporal_id + 1;
1265  d3d12va_pic->pic_ctl.pAV1PicData->SpatialLayerIndexPlus1 = hpic->spatial_id + 1;
1266  d3d12va_pic->pic_ctl.pAV1PicData->PictureIndex = pic->display_order;
1267  d3d12va_pic->pic_ctl.pAV1PicData->InterpolationFilter = D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_SWITCHABLE;
1268  d3d12va_pic->pic_ctl.pAV1PicData->PrimaryRefFrame = fh->primary_ref_frame;
1269  if (fh->error_resilient_mode)
1270  d3d12va_pic->pic_ctl.pAV1PicData->Flags |= D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_ERROR_RESILIENT_MODE;
1271 
1272  if (pic->type == FF_HW_PICTURE_TYPE_IDR)
1273  {
1274  for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1275  d3d12va_pic->pic_ctl.pAV1PicData->ReferenceFramesReconPictureDescriptors[i].ReconstructedPictureResourceIndex =
1276  D3D12_VIDEO_ENCODER_AV1_INVALID_DPB_RESOURCE_INDEX;
1277  }
1278  } else if (pic->type == FF_HW_PICTURE_TYPE_P) {
1279  for (i = 0; i < pic->nb_refs[0]; i++) {
1280  FFHWBaseEncodePicture *ref_pic = pic->refs[0][i];
1281  d3d12va_pic->pic_ctl.pAV1PicData->ReferenceFramesReconPictureDescriptors[i].ReconstructedPictureResourceIndex =
1282  ((D3D12VAEncodeAV1Picture*)ref_pic->codec_priv)->slot;
1283  }
1284  }
1285  // Set reference frame management
1286  memset(d3d12va_pic->pic_ctl.pAV1PicData->ReferenceIndices, 0, sizeof(UINT) * AV1_REFS_PER_FRAME);
1287  if (pic->type == FF_HW_PICTURE_TYPE_P) {
1288  for (i = 0; i < AV1_REFS_PER_FRAME; i++)
1289  d3d12va_pic->pic_ctl.pAV1PicData->ReferenceIndices[i] = fh->ref_frame_idx[i];
1290  }
1291 
1292  // Process ROI side data if present and supported
1293  if (base_ctx->roi_allowed && d3d12va_pic->qp_map && d3d12va_pic->qp_map_size > 0) {
1294  d3d12va_pic->pic_ctl.pAV1PicData->QPMapValuesCount = d3d12va_pic->qp_map_size;
1295  d3d12va_pic->pic_ctl.pAV1PicData->pRateControlQPMap = (INT16 *)d3d12va_pic->qp_map;
1296  }
1297 
1298  return av_fifo_write(priv->picture_header_list, &priv->units.raw_frame_header, 1);
1299 }
1300 
1301 
1302 static const D3D12VAEncodeType d3d12va_encode_type_av1 = {
1303  .profiles = d3d12va_encode_av1_profiles,
1304 
1305  .d3d12_codec = D3D12_VIDEO_ENCODER_CODEC_AV1,
1306 
1307  .flags = FF_HW_FLAG_B_PICTURES |
1308  FF_HW_FLAG_B_PICTURE_REFERENCES |
1309  FF_HW_FLAG_NON_IDR_KEY_PICTURES,
1310 
1311  .default_quality = 25,
1312 
1313  .get_encoder_caps = &d3d12va_encode_av1_get_encoder_caps,
1314 
1315  .configure = &d3d12va_encode_av1_configure,
1316 
1317  .set_level = &d3d12va_encode_av1_set_level,
1318 
1319  .set_tile = &d3d12va_encode_av1_set_tile,
1320 
1321  .picture_priv_data_size = sizeof(D3D12VAEncodeAV1Picture),
1322 
1323  .init_sequence_params = &d3d12va_encode_av1_init_sequence_params,
1324 
1325  .init_picture_params = &d3d12va_encode_av1_init_picture_params,
1326 
1327  .free_picture_params = &d3d12va_encode_av1_free_picture_params,
1328 
1329  .write_sequence_header = &d3d12va_encode_av1_write_sequence_header,
1330 
1331 #ifdef CONFIG_AV1_D3D12VA_ENCODER
1332  .get_coded_data = &d3d12va_encode_av1_get_coded_data,
1333 #endif
1334 };
1335 
1336 static int d3d12va_encode_av1_init(AVCodecContext *avctx)
1337 {
1338  D3D12VAEncodeContext *ctx = avctx->priv_data;
1339  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
1340 
1341  ctx->codec = &d3d12va_encode_type_av1;
1342 
1343  if (avctx->profile == AV_PROFILE_UNKNOWN)
1344  avctx->profile = priv->profile;
1345  if (avctx->level == AV_LEVEL_UNKNOWN)
1346  avctx->level = priv->level;
1347 
1348  if (avctx->level != AV_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1349  av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1350  "in 8-bit unsigned integer.\n", avctx->level);
1351  return AVERROR(EINVAL);
1352  }
1353 
1354  if (priv->qp > 0)
1355  ctx->explicit_qp = priv->qp;
1356 
1357  priv->picture_header_list = av_fifo_alloc2(2, sizeof(AV1RawOBU), AV_FIFO_FLAG_AUTO_GROW);
1358 
1359  return ff_d3d12va_encode_init(avctx);
1360 }
1361 
1362 static int d3d12va_encode_av1_close(AVCodecContext *avctx)
1363 {
1364  D3D12VAEncodeAV1Context *priv = avctx->priv_data;
1365 
1366  ff_cbs_fragment_free(&priv->current_obu);
1367  ff_cbs_close(&priv->cbc);
1368 
1369  av_freep(&priv->common.codec_conf.pAV1Config);
1370  av_freep(&priv->common.gop.pAV1SequenceStructure);
1371  av_freep(&priv->common.level.pAV1LevelSetting);
1372  av_freep(&priv->common.subregions_layout.pTilesPartition_AV1);
1373 
1374  av_fifo_freep2(&priv->picture_header_list);
1375 
1376  return ff_d3d12va_encode_close(avctx);
1377 }
1378 
1379 #define OFFSET(x) offsetof(D3D12VAEncodeAV1Context, x)
1380 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1381 static const AVOption d3d12va_encode_av1_options[] = {
1382  HW_BASE_ENCODE_COMMON_OPTIONS,
1383  D3D12VA_ENCODE_COMMON_OPTIONS,
1384  D3D12VA_ENCODE_RC_OPTIONS,
1385 
1386  { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1387  OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1388 
1389  { "profile", "Set profile (general_profile_idc)",
1390  OFFSET(profile), AV_OPT_TYPE_INT,
1391  { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xff, FLAGS, "profile" },
1392 
1393 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1394  { .i64 = value }, 0, 0, FLAGS, "profile"
1395  { PROFILE("main", AV_PROFILE_AV1_MAIN) },
1396  { PROFILE("high", AV_PROFILE_AV1_HIGH) },
1397  { PROFILE("professional", AV_PROFILE_AV1_PROFESSIONAL) },
1398 #undef PROFILE
1399 
1400  { "tier", "Set tier (general_tier_flag)",
1401  OFFSET(unit_opts.tier), AV_OPT_TYPE_INT,
1402  { .i64 = 0 }, 0, 1, FLAGS, "tier" },
1403  { "main", NULL, 0, AV_OPT_TYPE_CONST,
1404  { .i64 = 0 }, 0, 0, FLAGS, "tier" },
1405  { "high", NULL, 0, AV_OPT_TYPE_CONST,
1406  { .i64 = 1 }, 0, 0, FLAGS, "tier" },
1407 
1408  { "level", "Set level (general_level_idc)",
1409  OFFSET(level), AV_OPT_TYPE_INT,
1410  { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
1411 
1412 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1413  { .i64 = value }, 0, 0, FLAGS, "level"
1414  { LEVEL("2.0", 0) },
1415  { LEVEL("2.1", 1) },
1416  { LEVEL("2.2", 2) },
1417  { LEVEL("2.3", 3) },
1418  { LEVEL("3.0", 4) },
1419  { LEVEL("3.1", 5) },
1420  { LEVEL("3.2", 6) },
1421  { LEVEL("3.3", 7) },
1422  { LEVEL("4.0", 8) },
1423  { LEVEL("4.1", 9) },
1424  { LEVEL("4.2", 10) },
1425  { LEVEL("4.3", 11) },
1426  { LEVEL("5.0", 12) },
1427  { LEVEL("5.1", 13) },
1428  { LEVEL("5.2", 14) },
1429  { LEVEL("5.3", 15) },
1430  { LEVEL("6.0", 16) },
1431  { LEVEL("6.1", 17) },
1432  { LEVEL("6.2", 18) },
1433  { LEVEL("6.3", 19) },
1434  { LEVEL("7.0", 20) },
1435  { LEVEL("7.1", 21) },
1436  { LEVEL("7.2", 22) },
1437  { LEVEL("7.3", 23) },
1438 #undef LEVEL
1439 
1440  { "tiles", "Tile columns x rows (Use minimal tile column/row number "
1441  "automatically by default)",
1442  OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, FLAGS },
1443 
1444  { NULL },
1445 };
1446 
1447 static const FFCodecDefault d3d12va_encode_av1_defaults[] = {
1448  { "b", "0" },
1449  { "bf", "0" },
1450  { "g", "120" },
1451  { "i_qfactor", "1" },
1452  { "i_qoffset", "0" },
1453  { "b_qfactor", "1" },
1454  { "b_qoffset", "0" },
1455  { "qmin", "-1" },
1456  { "qmax", "-1" },
1457  { "refs", "0" },
1458  { NULL },
1459 };
1460 
1461 static const AVClass d3d12va_encode_av1_class = {
1462  .class_name = "av1_d3d12va",
1463  .item_name = av_default_item_name,
1464  .option = d3d12va_encode_av1_options,
1465  .version = LIBAVUTIL_VERSION_INT,
1466 };
1467 
1468 const FFCodec ff_av1_d3d12va_encoder = {
1469  .p.name = "av1_d3d12va",
1470  CODEC_LONG_NAME("D3D12VA av1 encoder"),
1471  .p.type = AVMEDIA_TYPE_VIDEO,
1472  .p.id = AV_CODEC_ID_AV1,
1473  .priv_data_size = sizeof(D3D12VAEncodeAV1Context),
1474  .init = &d3d12va_encode_av1_init,
1475  FF_CODEC_RECEIVE_PACKET_CB(&ff_d3d12va_encode_receive_packet),
1476  .close = &d3d12va_encode_av1_close,
1477  .p.priv_class = &d3d12va_encode_av1_class,
1478  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
1479  AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1480  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1481  FF_CODEC_CAP_INIT_CLEANUP,
1482  .defaults = d3d12va_encode_av1_defaults,
1483  CODEC_PIXFMTS(AV_PIX_FMT_D3D12),
1484  .hw_configs = ff_d3d12va_encode_hw_configs,
1485  .p.wrapper_name = "d3d12va",
1486 };
D3D12VAHWBaseEncodeAV1Opts::enable_masked_compound
int enable_masked_compound
Definition: d3d12va_encode_av1.c:77
D3D12VAHWBaseEncodeAV1Opts::enable_intra_block_copy
int enable_intra_block_copy
Definition: d3d12va_encode_av1.c:85
cbs.h
d3d12va_encode_av1_profiles
static const D3D12VAEncodeProfile d3d12va_encode_av1_profiles[]
Definition: d3d12va_encode_av1.c:172
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:401
AV1RawSequenceHeader::seq_force_integer_mv
uint8_t seq_force_integer_mv
Definition: cbs_av1.h:129
profile_high
static const D3D12_VIDEO_ENCODER_AV1_PROFILE profile_high
Definition: d3d12va_encode_av1.c:167
AV1_MAX_TILE_AREA
@ AV1_MAX_TILE_AREA
Definition: av1.h:80
profile_professional
static const D3D12_VIDEO_ENCODER_AV1_PROFILE profile_professional
Definition: d3d12va_encode_av1.c:168
level
uint8_t level
Definition: svq3.c:208
AV1RawFrameHeader::primary_ref_frame
uint8_t primary_ref_frame
Definition: cbs_av1.h:196
av_clip
#define av_clip
Definition: common.h:100
d3d12va_hw_base_encode_init_params_av1
static int d3d12va_hw_base_encode_init_params_av1(FFHWBaseEncodeContext *base_ctx, AVCodecContext *avctx, D3D12VAHWBaseEncodeAV1 *common, D3D12VAHWBaseEncodeAV1Opts *opts)
Definition: d3d12va_encode_av1.c:556
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
AV1RawSequenceHeader::seq_level_idx
uint8_t seq_level_idx[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:96
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
opt.h
D3D12VAHWBaseEncodeAV1::raw_frame_header
AV1RawOBU raw_frame_header
Definition: d3d12va_encode_av1.c:58
D3D12VAEncodeAV1Picture::last_idr_frame
uint16_t last_idr_frame
Definition: d3d12va_encode_av1.c:93
CodedBitstreamAV1Context::seen_frame_header
int seen_frame_header
Definition: cbs_av1.h:464
CodedBitstreamContext::priv_data
void * priv_data
Internal codec-specific data.
Definition: cbs.h:247
FF_HW_FLAG_B_PICTURES
@ FF_HW_FLAG_B_PICTURES
Definition: hw_base_encode.h:53
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:671
profile_main
static const D3D12_VIDEO_ENCODER_AV1_PROFILE profile_main
Definition: d3d12va_encode_av1.c:166
AV1RawSequenceHeader
Definition: cbs_av1.h:82
AV1RawFrameHeader::show_frame
uint8_t show_frame
Definition: cbs_av1.h:181
out
static FILE * out
Definition: movenc.c:55
D3D12VAEncodeAV1Picture::slot
uint8_t slot
Definition: d3d12va_encode_av1.c:94
FFHWBaseEncodePicture::priv
void * priv
Definition: hw_base_encode.h:63
FFHWBaseEncodePicture::codec_priv
void * codec_priv
Definition: hw_base_encode.h:65
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3460
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:127
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
AV1_CSP_VERTICAL
@ AV1_CSP_VERTICAL
Definition: av1.h:134
AV1RawFrameHeader::cdef_uv_pri_strength
uint8_t cdef_uv_pri_strength[8]
Definition: cbs_av1.h:277
ff_av1_guess_level
const AV1LevelDescriptor * ff_av1_guess_level(int64_t bitrate, int tier, int width, int height, int tiles, int tile_cols, float fps)
Guess the level of a stream from some parameters.
Definition: av1_levels.c:48
D3D12VAEncodeAV1Context::level
int level
Definition: d3d12va_encode_av1.c:102
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:664
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:783
AVPacket::data
uint8_t * data
Definition: packet.h:603
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:226
AVOption
AVOption.
Definition: opt.h:428
encode.h
b
#define b
Definition: input.c:43
d3d12va_encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:675
AV1RawFrameHeader::uniform_tile_spacing_flag
uint8_t uniform_tile_spacing_flag
Definition: cbs_av1.h:224
data
const char data[16]
Definition: mxf.c:149
high
int high
Definition: dovi_rpuenc.c:39
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:35
AV1RawTileGroup::tg_end
uint16_t tg_end
Definition: cbs_av1.h:313
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
d3d12va_encode_av1_defaults
static const FFCodecDefault d3d12va_encode_av1_defaults[]
Definition: d3d12va_encode_av1.c:1447
D3D12VAEncodePicture::qp_map_size
int qp_map_size
Definition: d3d12va_encode.h:63
d3d12va_encode_av1_update_current_frame_picture_header
static int d3d12va_encode_av1_update_current_frame_picture_header(AVCodecContext *avctx, D3D12VAEncodePicture *pic, AV1RawOBU *frameheader_obu)
Definition: d3d12va_encode_av1.c:236
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_PROFILE_AV1_PROFESSIONAL
#define AV_PROFILE_AV1_PROFESSIONAL
Definition: defs.h:171
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV1RawTileData::data
uint8_t * data
Definition: cbs_av1.h:301
AV1RawOBU::header
AV1RawOBUHeader header
Definition: cbs_av1.h:414
D3D12VAEncodeAV1TileInfo
Definition: d3d12va_encode_av1.c:160
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV1RawFrameHeader::loop_filter_level
uint8_t loop_filter_level[4]
Definition: cbs_av1.h:264
AV1ReferenceFrameState::order_hint
int order_hint
Definition: cbs_av1.h:447
AV1_SELECT_INTEGER_MV
@ AV1_SELECT_INTEGER_MV
Definition: av1.h:99
AV1RawFrameHeader::cdef_y_sec_strength
uint8_t cdef_y_sec_strength[8]
Definition: cbs_av1.h:276
AV1RawSequenceHeader::seq_profile
uint8_t seq_profile
Definition: cbs_av1.h:83
AV1RawFrameHeader::cdef_damping_minus_3
uint8_t cdef_damping_minus_3
Definition: cbs_av1.h:273
D3D12VAEncodeAV1Picture::temporal_id
uint8_t temporal_id
Definition: d3d12va_encode_av1.c:89
OFFSET
#define OFFSET(x)
Definition: d3d12va_encode_av1.c:1379
D3D12VAEncodePicture::resolved_metadata
ID3D12Resource * resolved_metadata
Definition: d3d12va_encode.h:53
av_always_inline
#define av_always_inline
Definition: attributes.h:76
D3D12VAHWBaseEncodeAV1Opts::enable_loop_filter
int enable_loop_filter
Definition: d3d12va_encode_av1.c:80
FFHWBaseEncodeContext
Definition: hw_base_encode.h:122
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:563
d3d12va_encode_av1_tile_log2
static av_always_inline int d3d12va_encode_av1_tile_log2(int blksize, int target)
Definition: d3d12va_encode_av1.c:753
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:84
AV1RawColorConfig
Definition: cbs_av1.h:50
ff_d3d12va_encode_check_encoder_feature_flags
void ff_d3d12va_encode_check_encoder_feature_flags(void *log_ctx, D3D12_VIDEO_ENCODER_VALIDATION_FLAGS flags)
Definition: d3d12va_encode.c:42
ff_d3d12va_encode_hw_configs
const AVCodecHWConfigInternal *const ff_d3d12va_encode_hw_configs[]
Definition: d3d12va_encode.c:37
AVCodecContext::i_quant_factor
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:806
AV1RawFrameHeader::loop_filter_ref_deltas
int8_t loop_filter_ref_deltas[AV1_TOTAL_REFS_PER_FRAME]
Definition: cbs_av1.h:269
D3D12VAEncodePicture::output_buffer_ref
AVBufferRef * output_buffer_ref
Definition: d3d12va_encode.h:49
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
D3D12VAHWBaseEncodeAV1Opts::enable_superres
int enable_superres
Definition: d3d12va_encode_av1.c:68
AV1RawFrameHeader::delta_q_u_dc
int8_t delta_q_u_dc
Definition: cbs_av1.h:242
D3D12VAEncodeContext::subregions_layout
D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA subregions_layout
Definition: d3d12va_encode.h:272
FF_HW_PICTURE_TYPE_B
@ FF_HW_PICTURE_TYPE_B
Definition: hw_base_encode.h:42
FFHWBaseEncodePicture::type
int type
Definition: hw_base_encode.h:78
AV1RawSequenceHeader::enable_ref_frame_mvs
uint8_t enable_ref_frame_mvs
Definition: cbs_av1.h:124
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:85
AV1_OBU_FRAME_HEADER
@ AV1_OBU_FRAME_HEADER
Definition: av1.h:32
D3D12VAEncodeAV1Context
Definition: d3d12va_encode_av1.c:97
D3D12VAEncodeAV1Context::tier
int tier
Definition: d3d12va_encode_av1.c:103
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
AV1RawSequenceHeader::enable_filter_intra
uint8_t enable_filter_intra
Definition: cbs_av1.h:115
D3D12VAEncodePicture::output_buffer
ID3D12Resource * output_buffer
Definition: d3d12va_encode.h:50
CodedBitstreamAV1Context::ref
AV1ReferenceFrameState ref[AV1_NUM_REF_FRAMES]
Definition: cbs_av1.h:491
D3D12VA_ENCODE_RC_OPTIONS
#define D3D12VA_ENCODE_RC_OPTIONS
Definition: d3d12va_encode.h:437
D3D12VAHWBaseEncodeAV1Opts::enable_dual_filter
int enable_dual_filter
Definition: d3d12va_encode_av1.c:82
FF_HW_PICTURE_TYPE_P
@ FF_HW_PICTURE_TYPE_P
Definition: hw_base_encode.h:41
AVRational::num
int num
Numerator.
Definition: rational.h:59
D3D12VAEncodeAV1Context::common
D3D12VAEncodeContext common
Definition: d3d12va_encode_av1.c:98
AV1RawFrameHeader::tx_mode
uint8_t tx_mode
Definition: cbs_av1.h:284
d3d12va_encode_av1_init_sequence_params
static int d3d12va_encode_av1_init_sequence_params(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:653
tiles
int tiles
Definition: av1_levels.c:72
AV1RawFrameHeader::base_q_idx
uint8_t base_q_idx
Definition: cbs_av1.h:239
cbs_av1.h
D3D12VAEncodeAV1Context::q_idx_idr
uint8_t q_idx_idr
Definition: d3d12va_encode_av1.c:105
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:657
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AV1RawSequenceHeader::enable_masked_compound
uint8_t enable_masked_compound
Definition: cbs_av1.h:118
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
main
int main
Definition: dovi_rpuenc.c:38
FFHWBaseEncodeContext::ref_l0
int ref_l0
Definition: hw_base_encode.h:197
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AV1_MAX_TILE_COLS
@ AV1_MAX_TILE_COLS
Definition: av1.h:82
AV1RawFrameHeader::cdef_uv_sec_strength
uint8_t cdef_uv_sec_strength[8]
Definition: cbs_av1.h:278
D3D12VA_ENCODE_COMMON_OPTIONS
#define D3D12VA_ENCODE_COMMON_OPTIONS
Definition: d3d12va_encode.h:403
AV1RawFrameHeader::qm_y
uint8_t qm_y
Definition: cbs_av1.h:247
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:129
D3D12VAHWBaseEncodeAV1Opts::enable_cdef
int enable_cdef
Definition: d3d12va_encode_av1.c:66
AV1RawFrameHeader::render_width_minus_1
uint16_t render_width_minus_1
Definition: cbs_av1.h:202
AV1RawFrameHeader::update_mode_delta
uint8_t update_mode_delta[2]
Definition: cbs_av1.h:270
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:142
D3D12VAEncodePicture::header_size
int header_size
Definition: d3d12va_encode.h:43
FLAGS
#define FLAGS
Definition: d3d12va_encode_av1.c:1380
d3d12va_encode_av1_options
static const AVOption d3d12va_encode_av1_options[]
Definition: d3d12va_encode_av1.c:1381
D3D12VAEncodeAV1Level
Definition: d3d12va_encode_av1.c:128
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:141
tile_rows
int tile_rows
Definition: h265_levels.c:217
d3d12va_encode_av1_class
static const AVClass d3d12va_encode_av1_class
Definition: d3d12va_encode_av1.c:1461
D3D12VAHWBaseEncodeAV1Opts::enable_interintra_compound
int enable_interintra_compound
Definition: d3d12va_encode_av1.c:76
d3d12va_encode_av1_configure
static int d3d12va_encode_av1_configure(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:1026
tile_cols
int tile_cols
Definition: av1_levels.c:73
CodedBitstreamUnitType
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:54
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AV1RawFrameHeader::frame_width_minus_1
uint16_t frame_width_minus_1
Definition: cbs_av1.h:197
D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_CONFIGURABLE_GRID_PARTITION
#define D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_CONFIGURABLE_GRID_PARTITION
Definition: d3d12va_encode_av1.c:48
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
hw_base_encode.h
D3D12VAEncodePicture::pic_ctl
D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA pic_ctl
Definition: d3d12va_encode.h:57
AV1RawSequenceHeader::seq_tier
uint8_t seq_tier[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:97
CodedBitstreamFragment::data_bit_padding
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:146
AV1RawFrameHeader::loop_filter_mode_deltas
int8_t loop_filter_mode_deltas[2]
Definition: cbs_av1.h:271
color_range
color_range
Definition: vf_selectivecolor.c:43
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:645
AV1_TX_MODE_SELECT
@ AV1_TX_MODE_SELECT
Definition: av1.h:183
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:349
FFHWBaseEncodeContext::b_per_p
int b_per_p
Definition: hw_base_encode.h:189
if
if(ret)
Definition: filter_design.txt:179
D3D12VAHWBaseEncodeAV1Opts
Definition: d3d12va_encode_av1.c:62
D3D12VAHWBaseEncodeAV1
Definition: d3d12va_encode_av1.c:56
fail
#define fail
Definition: test.h:478
opts
static AVDictionary * opts
Definition: movenc.c:51
framerate
float framerate
Definition: av1_levels.c:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV1RawOBU
Definition: cbs_av1.h:413
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
AV1RawFrameHeader::qm_v
uint8_t qm_v
Definition: cbs_av1.h:249
AV1RawFrameHeader::tile_size_bytes_minus1
uint8_t tile_size_bytes_minus1
Definition: cbs_av1.h:232
AV1RawFrameHeader::is_filter_switchable
uint8_t is_filter_switchable
Definition: cbs_av1.h:217
D3D12VAEncodeAV1Context::qp
int qp
Definition: d3d12va_encode_av1.c:100
NULL
#define NULL
Definition: coverity.c:32
AV1_MAX_TILE_WIDTH
@ AV1_MAX_TILE_WIDTH
Definition: av1.h:79
D3D12VAHWBaseEncodeAV1Opts::enable_jnt_comp
int enable_jnt_comp
Definition: d3d12va_encode_av1.c:71
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:213
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:681
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
D3D12VAEncodeAV1Context::uniform_tile_spacing
int uniform_tile_spacing
Definition: d3d12va_encode_av1.c:121
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:275
AV1RawFrameHeader
Definition: cbs_av1.h:174
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:804
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:209
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:135
AV1RawFrameHeader::width_in_sbs_minus_1
uint8_t width_in_sbs_minus_1[AV1_MAX_TILE_COLS]
Definition: cbs_av1.h:229
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:806
d3d12va_encode_av1_free_picture_params
static void d3d12va_encode_av1_free_picture_params(D3D12VAEncodePicture *pic)
Definition: d3d12va_encode_av1.c:1130
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:384
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:493
AV1_INTERPOLATION_FILTER_SWITCHABLE
@ AV1_INTERPOLATION_FILTER_SWITCHABLE
Definition: av1.h:104
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:302
D3D12VAHWBaseEncodeAV1::raw_tile_group
AV1RawOBU raw_tile_group
Definition: d3d12va_encode_av1.c:59
d3d12va_encode_av1_write_tile_group
static int d3d12va_encode_av1_write_tile_group(AVCodecContext *avctx, uint8_t *tile_group, uint32_t tile_group_size, char *data, size_t *data_len)
Definition: d3d12va_encode_av1.c:353
AV1RawTileData::data_size
size_t data_size
Definition: cbs_av1.h:303
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
AV1RawColorConfig::chroma_sample_position
uint8_t chroma_sample_position
Definition: cbs_av1.h:63
AV1_OBU_TILE_GROUP
@ AV1_OBU_TILE_GROUP
Definition: av1.h:33
AV1RawSequenceHeader::enable_jnt_comp
uint8_t enable_jnt_comp
Definition: cbs_av1.h:123
AVD3D12VAFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_d3d12va.h:172
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
D3D12VAEncodeAV1Picture::show_frame
uint8_t show_frame
Definition: d3d12va_encode_av1.c:91
D3D12VAEncodeAV1Context::profile
int profile
Definition: d3d12va_encode_av1.c:101
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1646
AV1RawSequenceHeader::seq_force_screen_content_tools
uint8_t seq_force_screen_content_tools
Definition: cbs_av1.h:127
d3d12va_encode_av1_set_level
static int d3d12va_encode_av1_set_level(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:1080
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
D3D12VAEncodeAV1Context::unit_opts
D3D12VAHWBaseEncodeAV1Opts unit_opts
Definition: d3d12va_encode_av1.c:110
AV1RawFrameHeader::delta_q_res
uint8_t delta_q_res
Definition: cbs_av1.h:259
D3D12VAEncodeAV1Context::units
D3D12VAHWBaseEncodeAV1 units
Definition: d3d12va_encode_av1.c:109
AV1RawSequenceHeader::max_frame_height_minus_1
uint16_t max_frame_height_minus_1
Definition: cbs_av1.h:108
D3D12VAHWBaseEncodeAV1Opts::enable_ref_frame_mvs
int enable_ref_frame_mvs
Definition: d3d12va_encode_av1.c:69
AV1RawFrameHeader::interpolation_filter
uint8_t interpolation_filter
Definition: cbs_av1.h:218
D3D12VAHWBaseEncodeAV1Opts::tier
int tier
Definition: d3d12va_encode_av1.c:63
D3D12VAEncodeContext::codec_conf
D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION codec_conf
Definition: d3d12va_encode.h:264
AV1RawFrameHeader::ref_frame_idx
int8_t ref_frame_idx[AV1_REFS_PER_FRAME]
Definition: cbs_av1.h:213
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:608
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:49
AVFifo
Definition: fifo.c:35
d3d12va_encode_av1_init_picture_params
static int d3d12va_encode_av1_init_picture_params(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
Definition: d3d12va_encode_av1.c:1138
AV1RawFrameHeader::refresh_frame_flags
uint8_t refresh_frame_flags
Definition: cbs_av1.h:207
height
#define height
Definition: dsp.h:89
AV1RawFrameHeader::cdef_bits
uint8_t cdef_bits
Definition: cbs_av1.h:274
D3D12VAEncodeAV1Level::level
uint8_t level
Definition: d3d12va_encode_av1.c:129
codec_internal.h
D3D_PROFILE_DESC
#define D3D_PROFILE_DESC(name)
Definition: d3d12va_encode_av1.c:170
ff_d3d12va_encode_init
int ff_d3d12va_encode_init(AVCodecContext *avctx)
Definition: d3d12va_encode.c:1728
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
FFHWBaseEncodePicture::nb_refs
int nb_refs[MAX_REFERENCE_LIST_NUM]
Definition: hw_base_encode.h:97
AV1RawFrameHeader::tile_cols_log2
uint8_t tile_cols_log2
Definition: cbs_av1.h:225
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
D3D12VAEncodeProfile
Definition: d3d12va_encode.h:66
D3D12VAEncodeAV1Context::tile_cols_log2
int tile_cols_log2
Definition: d3d12va_encode_av1.c:119
AV1RawOBU::sequence_header
AV1RawSequenceHeader sequence_header
Definition: cbs_av1.h:419
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:135
AV1RawSequenceHeader::use_128x128_superblock
uint8_t use_128x128_superblock
Definition: cbs_av1.h:114
AV1RawSequenceHeader::frame_height_bits_minus_1
uint8_t frame_height_bits_minus_1
Definition: cbs_av1.h:106
LEVEL
#define LEVEL(name, value)
av_malloc
#define av_malloc(s)
Definition: ops_static.c:44
d3d12va_encode_av1_write_picture_header
static int d3d12va_encode_av1_write_picture_header(AVCodecContext *avctx, D3D12VAEncodePicture *pic, char *data, size_t *data_len)
Definition: d3d12va_encode_av1.c:323
AV1_OBU_SEQUENCE_HEADER
@ AV1_OBU_SEQUENCE_HEADER
Definition: av1.h:30
AV1LevelDescriptor
Definition: av1_levels.h:26
FFHWBaseEncodePicture::encode_order
int64_t encode_order
Definition: hw_base_encode.h:70
AV1RawSequenceHeader::still_picture
uint8_t still_picture
Definition: cbs_av1.h:84
D3D12VAHWBaseEncodeAV1Opts::enable_intra_edge_filter
int enable_intra_edge_filter
Definition: d3d12va_encode_av1.c:75
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_PROFILE_AV1_HIGH
#define AV_PROFILE_AV1_HIGH
Definition: defs.h:170
AV1RawSequenceHeader::enable_interintra_compound
uint8_t enable_interintra_compound
Definition: cbs_av1.h:117
FFHWBaseEncodeContext::roi_allowed
int roi_allowed
Definition: hw_base_encode.h:201
D3D12VAEncodeAV1Context::tile_cols
int tile_cols
Definition: d3d12va_encode_av1.c:117
AV1RawFrameHeader::order_hint
uint8_t order_hint
Definition: cbs_av1.h:191
D3D12VAEncodeAV1TileInfo::data
uint64_t data
Definition: d3d12va_encode_av1.c:163
d3d12va_encode_av1_write_obu
static int d3d12va_encode_av1_write_obu(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *obu)
Definition: d3d12va_encode_av1.c:182
AV1RawOBU::frame_header
AV1RawFrameHeader frame_header
Definition: cbs_av1.h:420
D3D12VAEncodePicture
Definition: d3d12va_encode.h:42
AV1RawFrameHeader::delta_q_v_dc
int8_t delta_q_v_dc
Definition: cbs_av1.h:244
AV1_TOTAL_REFS_PER_FRAME
@ AV1_TOTAL_REFS_PER_FRAME
Definition: av1.h:86
D3D12VAHWBaseEncodeAV1Opts::enable_warped_motion
int enable_warped_motion
Definition: d3d12va_encode_av1.c:74
D3D12VAEncodeAV1Context::width_in_sbs_minus_1
uint8_t width_in_sbs_minus_1[AV1_MAX_TILE_COLS]
Definition: d3d12va_encode_av1.c:124
D3D12VAEncodeContext::level
D3D12_VIDEO_ENCODER_LEVEL_SETTING level
Definition: d3d12va_encode.h:270
d3d12va_encode_av1_write_sequence_header
static int d3d12va_encode_av1_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
Definition: d3d12va_encode_av1.c:217
D3D12VAHWBaseEncodeAV1::raw_sequence_header
AV1RawOBU raw_sequence_header
Definition: d3d12va_encode_av1.c:57
D3D12VAEncodePicture::qp_map
void * qp_map
Definition: d3d12va_encode.h:62
D3D12VAEncodeAV1Level::d3d12_level
D3D12_VIDEO_ENCODER_AV1_LEVELS d3d12_level
Definition: d3d12va_encode_av1.c:130
AV1RawSequenceHeader::enable_dual_filter
uint8_t enable_dual_filter
Definition: cbs_av1.h:120
AV1RawSequenceHeader::enable_superres
uint8_t enable_superres
Definition: cbs_av1.h:133
D3D12VAEncodeAV1Context::tile_rows
int tile_rows
Definition: d3d12va_encode_av1.c:118
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
common.h
d3d12va_encode_type_av1
static const D3D12VAEncodeType d3d12va_encode_type_av1
Definition: d3d12va_encode_av1.c:1302
AV1RawFrameHeader::tile_rows
uint16_t tile_rows
Definition: cbs_av1.h:237
AV1RawSequenceHeader::enable_intra_edge_filter
uint8_t enable_intra_edge_filter
Definition: cbs_av1.h:116
D3D12_VIDEO_ENCODER_AV1_INVALID_DPB_RESOURCE_INDEX
#define D3D12_VIDEO_ENCODER_AV1_INVALID_DPB_RESOURCE_INDEX
Definition: d3d12va_encode_av1.c:53
AV1RawSequenceHeader::max_frame_width_minus_1
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:107
FFHWBaseEncodePicture::refs
struct FFHWBaseEncodePicture * refs[MAX_REFERENCE_LIST_NUM][MAX_PICTURE_REFERENCES]
Definition: hw_base_encode.h:98
AV1RawSequenceHeader::color_config
AV1RawColorConfig color_config
Definition: cbs_av1.h:137
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:176
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:688
AV1RawTileGroup::tg_start
uint16_t tg_start
Definition: cbs_av1.h:312
profile
int profile
Definition: mxfenc.c:2299
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:709
D3D12VAHWBaseEncodeAV1Opts::enable_filter_intra
int enable_filter_intra
Definition: d3d12va_encode_av1.c:78
AV1RawSequenceHeader::enable_order_hint
uint8_t enable_order_hint
Definition: cbs_av1.h:122
AV1RawFrameHeader::loop_filter_delta_enabled
uint8_t loop_filter_delta_enabled
Definition: cbs_av1.h:266
AVCodecContext::height
int height
Definition: avcodec.h:604
av1_levels
static const D3D12VAEncodeAV1Level av1_levels[]
Definition: d3d12va_encode_av1.c:133
AV1_MAX_TILE_ROWS
@ AV1_MAX_TILE_ROWS
Definition: av1.h:81
avcodec.h
d3d12va_encode_av1_close
static int d3d12va_encode_av1_close(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:1362
AV1RawTileGroup::tile_data
AV1RawTileData tile_data
Definition: cbs_av1.h:315
AVD3D12VAFramesContext::format
DXGI_FORMAT format
DXGI_FORMAT format.
Definition: hwcontext_d3d12va.h:177
AV1RawFrameHeader::ref_order_hint
uint8_t ref_order_hint[AV1_NUM_REF_FRAMES]
Definition: cbs_av1.h:209
AV1RawFrameHeader::height_in_sbs_minus_1
uint8_t height_in_sbs_minus_1[AV1_MAX_TILE_ROWS]
Definition: cbs_av1.h:230
tile_group_obu
static int FUNC() tile_group_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileGroup *current)
Definition: cbs_av1_syntax_template.c:1831
AV1_TX_MODE_LARGEST
@ AV1_TX_MODE_LARGEST
Definition: av1.h:182
FFHWBaseEncodeContext::gop_size
int gop_size
Definition: hw_base_encode.h:184
FFHWBaseEncodePicture
Definition: hw_base_encode.h:61
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:153
D3D12VAEncodeContext
Definition: d3d12va_encode.h:150
AV1RawColorConfig::high_bitdepth
uint8_t high_bitdepth
Definition: cbs_av1.h:51
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
FF_HW_FLAG_NON_IDR_KEY_PICTURES
@ FF_HW_FLAG_NON_IDR_KEY_PICTURES
Definition: hw_base_encode.h:58
AV1RawFrameHeader::update_ref_delta
uint8_t update_ref_delta[AV1_TOTAL_REFS_PER_FRAME]
Definition: cbs_av1.h:268
AV1RawFrameHeader::using_qmatrix
uint8_t using_qmatrix
Definition: cbs_av1.h:246
AV1RawSequenceHeader::frame_width_bits_minus_1
uint8_t frame_width_bits_minus_1
Definition: cbs_av1.h:105
AV1RawSequenceHeader::enable_warped_motion
uint8_t enable_warped_motion
Definition: cbs_av1.h:119
FFHWBaseEncodeContext::surface_height
int surface_height
Definition: hw_base_encode.h:141
D3D12VAEncodeAV1Picture::spatial_id
uint8_t spatial_id
Definition: d3d12va_encode_av1.c:90
AVCodecContext
main external API structure.
Definition: avcodec.h:443
AV1RawTileGroup::tile_start_and_end_present_flag
uint8_t tile_start_and_end_present_flag
Definition: cbs_av1.h:311
write_sequence_header
static int write_sequence_header(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic, uint8_t *data, size_t *data_len)
Definition: vulkan_encode_av1.c:1097
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:105
d3d12va_encode_av1_set_tile
static int d3d12va_encode_av1_set_tile(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:760
MAX_PARAM_BUFFER_SIZE
@ MAX_PARAM_BUFFER_SIZE
Definition: vaapi_encode.h:47
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:258
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1636
D3D12VAHWBaseEncodeAV1Opts::enable_restoration
int enable_restoration
Definition: d3d12va_encode_av1.c:67
av1_levels.h
ff_av1_d3d12va_encoder
const FFCodec ff_av1_d3d12va_encoder
Definition: d3d12va_encode_av1.c:1468
AV1RawFrameHeader::frame_height_minus_1
uint16_t frame_height_minus_1
Definition: cbs_av1.h:198
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:813
D3D12VAEncodePicture::aligned_header_size
int aligned_header_size
Definition: d3d12va_encode.h:44
D3D12VAEncodeAV1TileInfo::prefix
uint64_t prefix
Definition: d3d12va_encode_av1.c:162
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
AV1RawFrameHeader::context_update_tile_id
uint16_t context_update_tile_id
Definition: cbs_av1.h:231
D3D12VAHWBaseEncodeAV1Opts::level
int level
Definition: d3d12va_encode_av1.c:64
FFHWBaseEncodeContext::input_frames
AVHWFramesContext * input_frames
Definition: hw_base_encode.h:153
D3D12VAEncodeAV1Context::height_in_sbs_minus_1
uint8_t height_in_sbs_minus_1[AV1_MAX_TILE_ROWS]
Definition: d3d12va_encode_av1.c:125
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:73
D3D12VAEncodeAV1Picture
Definition: d3d12va_encode_av1.c:88
D3D12VAHWBaseEncodeAV1Opts::enable_palette
int enable_palette
Definition: d3d12va_encode_av1.c:84
FFHWBaseEncodeContext::surface_width
int surface_width
Definition: hw_base_encode.h:140
AV1RawSequenceHeader::order_hint_bits_minus_1
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:131
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
AV1RawTileGroup
Definition: cbs_av1.h:306
AV1RawFrameHeader::loop_filter_sharpness
uint8_t loop_filter_sharpness
Definition: cbs_av1.h:265
D3D12VAEncodeContext::gop
D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE gop
Definition: d3d12va_encode.h:268
D3D12VAEncodeAV1TileInfo::full
uint64_t full
Definition: d3d12va_encode_av1.c:161
AV1RawFrameHeader::delta_q_v_ac
int8_t delta_q_v_ac
Definition: cbs_av1.h:245
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
D3D12VAHWBaseEncodeAV1Opts::enable_128x128_superblock
int enable_128x128_superblock
Definition: d3d12va_encode_av1.c:72
mem.h
D3D12VAHWBaseEncodeAV1Opts::enable_loop_filter_delta
int enable_loop_filter_delta
Definition: d3d12va_encode_av1.c:81
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV1RawSequenceHeader::enable_restoration
uint8_t enable_restoration
Definition: cbs_av1.h:135
ff_d3d12va_encode_close
int ff_d3d12va_encode_close(AVCodecContext *avctx)
Definition: d3d12va_encode.c:1888
AV1RawFrameHeader::error_resilient_mode
uint8_t error_resilient_mode
Definition: cbs_av1.h:184
AV1RawFrameHeader::delta_q_u_ac
int8_t delta_q_u_ac
Definition: cbs_av1.h:243
AV1RawFrameHeader::tile_rows_log2
uint8_t tile_rows_log2
Definition: cbs_av1.h:226
d3d12va_encode_av1_init
static int d3d12va_encode_av1_init(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:1336
D3D12VAEncodeAV1Context::tile_size_bytes
int tile_size_bytes
Definition: d3d12va_encode_av1.c:122
D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_GRID_PARTITION
#define D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_GRID_PARTITION
Definition: d3d12va_encode_av1.c:44
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
ff_d3d12va_encode_receive_packet
int ff_d3d12va_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: d3d12va_encode.c:1723
AVPacket
This structure stores compressed data.
Definition: packet.h:580
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:470
FF_HW_PICTURE_TYPE_IDR
@ FF_HW_PICTURE_TYPE_IDR
Definition: hw_base_encode.h:39
d3d12va_encode_av1_add_obu
static int d3d12va_encode_av1_add_obu(AVCodecContext *avctx, CodedBitstreamFragment *au, CodedBitstreamUnitType obu_type, void *obu_unit)
Definition: d3d12va_encode_av1.c:201
AV1RawTileData::data_ref
AVBufferRef * data_ref
Definition: cbs_av1.h:302
D3D12VAEncodeAV1Context::current_obu
CodedBitstreamFragment current_obu
Definition: d3d12va_encode_av1.c:113
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV1RawFrameHeader::delta_q_present
uint8_t delta_q_present
Definition: cbs_av1.h:258
D3D12VAEncodeAV1Context::post_encode_values_flag
D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS post_encode_values_flag
Definition: d3d12va_encode_av1.c:114
AV1RawSequenceHeader::enable_cdef
uint8_t enable_cdef
Definition: cbs_av1.h:134
d3d12va_encode_av1_get_coded_data
static int d3d12va_encode_av1_get_coded_data(AVCodecContext *avctx, D3D12VAEncodePicture *pic, AVPacket *pkt)
Definition: d3d12va_encode_av1.c:448
AV1RawSequenceHeader::reduced_still_picture_header
uint8_t reduced_still_picture_header
Definition: cbs_av1.h:85
D3D12VAEncodeType::profiles
const D3D12VAEncodeProfile * profiles
List of supported profiles.
Definition: d3d12va_encode.h:303
d3d12va_encode_av1_get_buffer_size
static int d3d12va_encode_av1_get_buffer_size(AVCodecContext *avctx, D3D12VAEncodePicture *pic, uint64_t tile_size_bytes, uint64_t *nb_subregions_out, D3D12VAEncodeAV1TileInfo **tiles_out, size_t *tile_payload_size_out)
Definition: d3d12va_encode_av1.c:384
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:87
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
AV1RawOBU::obu
union AV1RawOBU::@90 obu
AV1_CSP_UNKNOWN
@ AV1_CSP_UNKNOWN
Definition: av1.h:133
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FF_HW_FLAG_B_PICTURE_REFERENCES
@ FF_HW_FLAG_B_PICTURE_REFERENCES
Definition: hw_base_encode.h:55
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
HW_BASE_ENCODE_COMMON_OPTIONS
#define HW_BASE_ENCODE_COMMON_OPTIONS
Definition: hw_base_encode.h:243
D3D12VAEncodeAV1Context::tile_rows_log2
int tile_rows_log2
Definition: d3d12va_encode_av1.c:120
D3D12VAEncodeType
Definition: d3d12va_encode.h:299
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
D3D12VAEncodeAV1Context::q_idx_p
uint8_t q_idx_p
Definition: d3d12va_encode_av1.c:106
D3D12VAEncodeAV1Picture::frame_type
uint8_t frame_type
Definition: d3d12va_encode_av1.c:92
width
#define width
Definition: dsp.h:89
AV1RawFrameHeader::qm_u
uint8_t qm_u
Definition: cbs_av1.h:248
hwcontext_d3d12va_internal.h
D3D12VAEncodeAV1Context::context_update_tile_id
uint16_t context_update_tile_id
Definition: d3d12va_encode_av1.c:123
FFHWBaseEncodePicture::display_order
int64_t display_order
Definition: hw_base_encode.h:69
AV1RawFrameHeader::cdef_y_pri_strength
uint8_t cdef_y_pri_strength[8]
Definition: cbs_av1.h:275
AV_PROFILE_AV1_MAIN
#define AV_PROFILE_AV1_MAIN
Definition: defs.h:169
AV1RawFrameHeader::delta_q_y_dc
int8_t delta_q_y_dc
Definition: cbs_av1.h:240
AV1RawFrameHeader::showable_frame
uint8_t showable_frame
Definition: cbs_av1.h:182
AV1RawOBUHeader::obu_has_size_field
uint8_t obu_has_size_field
Definition: cbs_av1.h:42
d3d12va_encode_av1_get_encoder_caps
static int d3d12va_encode_av1_get_encoder_caps(AVCodecContext *avctx)
Definition: d3d12va_encode_av1.c:919
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:298
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV1RawFrameHeader::tile_cols
uint16_t tile_cols
Definition: cbs_av1.h:236
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:63
PROFILE
#define PROFILE(name, value)
AV1RawFrameHeader::render_height_minus_1
uint16_t render_height_minus_1
Definition: cbs_av1.h:203
D3D12VAEncodeAV1Context::cbc
CodedBitstreamContext * cbc
Definition: d3d12va_encode_av1.c:112
AV1RawFrameHeader::frame_type
uint8_t frame_type
Definition: cbs_av1.h:180
CodedBitstreamAV1Context
Definition: cbs_av1.h:457
D3D12VAEncodeAV1Context::picture_header_list
AVFifo * picture_header_list
Definition: d3d12va_encode_av1.c:115
AV1RawOBUHeader::obu_type
uint8_t obu_type
Definition: cbs_av1.h:40
Generated on Mon Jul 27 2026 19:22:15 for FFmpeg by   doxygen 1.8.17