FFmpeg
dxva2_h264.c
Go to the documentation of this file.
1 /*
2  * DXVA2 H.264 HW acceleration.
3  *
4  * copyright (c) 2009 Laurent Aimar
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 "config_components.h"
24 
25 #include "libavutil/avassert.h"
26 
27 #include "dxva2_internal.h"
28 #include "h264dec.h"
29 #include "h264data.h"
30 #include "h264_ps.h"
31 #include "hwaccel_internal.h"
32 #include "mpegutils.h"
33 
35  DXVA_PicParams_H264 pp;
36  DXVA_Qmatrix_H264 qm;
37  unsigned slice_count;
38  DXVA_Slice_H264_Short slice_short[MAX_SLICES];
39  DXVA_Slice_H264_Long slice_long[MAX_SLICES];
40  const uint8_t *bitstream;
41  unsigned bitstream_size;
42 };
43 
44 static void fill_picture_entry(DXVA_PicEntry_H264 *pic,
45  unsigned index, unsigned flag)
46 {
47  assert((index&0x7f) == index && (flag&0x01) == flag);
48  pic->bPicEntry = index | (flag << 7);
49 }
50 
52  DXVA_PicParams_H264 *pp)
53 {
54  const H264Picture *current_picture = h->cur_pic_ptr;
55  const SPS *sps = h->ps.sps;
56  const PPS *pps = h->ps.pps;
57  int i, j;
58 
59  memset(pp, 0, sizeof(*pp));
60  /* Configure current picture */
61  fill_picture_entry(&pp->CurrPic,
62  ff_dxva2_get_surface_index(avctx, ctx, current_picture->f),
63  h->picture_structure == PICT_BOTTOM_FIELD);
64  /* Configure the set of references */
65  pp->UsedForReferenceFlags = 0;
66  pp->NonExistingFrameFlags = 0;
67  for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) {
68  const H264Picture *r;
69  if (j < h->short_ref_count) {
70  r = h->short_ref[j++];
71  } else {
72  r = NULL;
73  while (!r && j < h->short_ref_count + 16)
74  r = h->long_ref[j++ - h->short_ref_count];
75  }
76  if (r) {
77  fill_picture_entry(&pp->RefFrameList[i],
78  ff_dxva2_get_surface_index(avctx, ctx, r->f),
79  r->long_ref != 0);
80 
81  if ((r->reference & PICT_TOP_FIELD) && r->field_poc[0] != INT_MAX)
82  pp->FieldOrderCntList[i][0] = r->field_poc[0];
83  if ((r->reference & PICT_BOTTOM_FIELD) && r->field_poc[1] != INT_MAX)
84  pp->FieldOrderCntList[i][1] = r->field_poc[1];
85 
86  pp->FrameNumList[i] = r->long_ref ? r->pic_id : r->frame_num;
87  if (r->reference & PICT_TOP_FIELD)
88  pp->UsedForReferenceFlags |= 1 << (2*i + 0);
89  if (r->reference & PICT_BOTTOM_FIELD)
90  pp->UsedForReferenceFlags |= 1 << (2*i + 1);
91  } else {
92  pp->RefFrameList[i].bPicEntry = 0xff;
93  pp->FieldOrderCntList[i][0] = 0;
94  pp->FieldOrderCntList[i][1] = 0;
95  pp->FrameNumList[i] = 0;
96  }
97  }
98 
99  pp->wFrameWidthInMbsMinus1 = h->mb_width - 1;
100  pp->wFrameHeightInMbsMinus1 = h->mb_height - 1;
101  pp->num_ref_frames = sps->ref_frame_count;
102 
103  pp->wBitFields = ((h->picture_structure != PICT_FRAME) << 0) |
104  ((sps->mb_aff &&
105  (h->picture_structure == PICT_FRAME)) << 1) |
106  (sps->residual_color_transform_flag << 2) |
107  /* sp_for_switch_flag (not implemented by FFmpeg) */
108  (0 << 3) |
109  (sps->chroma_format_idc << 4) |
110  ((h->nal_ref_idc != 0) << 6) |
111  (pps->constrained_intra_pred << 7) |
112  (pps->weighted_pred << 8) |
113  (pps->weighted_bipred_idc << 9) |
114  /* MbsConsecutiveFlag */
115  (1 << 11) |
116  (sps->frame_mbs_only_flag << 12) |
117  (pps->transform_8x8_mode << 13) |
118  ((sps->level_idc >= 31) << 14) |
119  /* IntraPicFlag (Modified if we detect a non
120  * intra slice in dxva2_h264_decode_slice) */
121  (1 << 15);
122 
123  pp->bit_depth_luma_minus8 = sps->bit_depth_luma - 8;
124  pp->bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8;
125  if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG)
126  pp->Reserved16Bits = 0;
127  else if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)
128  pp->Reserved16Bits = 0x34c;
129  else
130  pp->Reserved16Bits = 3; /* FIXME is there a way to detect the right mode ? */
131  pp->StatusReportFeedbackNumber = 1 + DXVA_CONTEXT_REPORT_ID(avctx, ctx)++;
132  pp->CurrFieldOrderCnt[0] = 0;
133  if ((h->picture_structure & PICT_TOP_FIELD) &&
134  current_picture->field_poc[0] != INT_MAX)
135  pp->CurrFieldOrderCnt[0] = current_picture->field_poc[0];
136  pp->CurrFieldOrderCnt[1] = 0;
137  if ((h->picture_structure & PICT_BOTTOM_FIELD) &&
138  current_picture->field_poc[1] != INT_MAX)
139  pp->CurrFieldOrderCnt[1] = current_picture->field_poc[1];
140  pp->pic_init_qs_minus26 = pps->init_qs - 26;
141  pp->chroma_qp_index_offset = pps->chroma_qp_index_offset[0];
142  pp->second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1];
143  pp->ContinuationFlag = 1;
144  pp->pic_init_qp_minus26 = pps->init_qp - 26;
145  pp->num_ref_idx_l0_active_minus1 = pps->ref_count[0] - 1;
146  pp->num_ref_idx_l1_active_minus1 = pps->ref_count[1] - 1;
147  pp->Reserved8BitsA = 0;
148  pp->frame_num = h->poc.frame_num;
149  pp->log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4;
150  pp->pic_order_cnt_type = sps->poc_type;
151  if (sps->poc_type == 0)
152  pp->log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4;
153  else if (sps->poc_type == 1)
154  pp->delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag;
155  pp->direct_8x8_inference_flag = sps->direct_8x8_inference_flag;
156  pp->entropy_coding_mode_flag = pps->cabac;
157  pp->pic_order_present_flag = pps->pic_order_present;
158  pp->num_slice_groups_minus1 = pps->slice_group_count - 1;
159  pp->slice_group_map_type = pps->mb_slice_group_map_type;
160  pp->deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present;
161  pp->redundant_pic_cnt_present_flag= pps->redundant_pic_cnt_present;
162  pp->Reserved8BitsB = 0;
163  pp->slice_group_change_rate_minus1= 0; /* XXX not implemented by FFmpeg */
164  //pp->SliceGroupMap[810]; /* XXX not implemented by FFmpeg */
165 }
166 
167 static void fill_scaling_lists(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
168 {
169  const PPS *pps = h->ps.pps;
170  unsigned i, j;
171  memset(qm, 0, sizeof(*qm));
172  if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG) {
173  for (i = 0; i < 6; i++)
174  for (j = 0; j < 16; j++)
175  qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][j];
176 
177  for (i = 0; i < 64; i++) {
178  qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][i];
179  qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][i];
180  }
181  } else {
182  for (i = 0; i < 6; i++)
183  for (j = 0; j < 16; j++)
184  qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][ff_zigzag_scan[j]];
185 
186  for (i = 0; i < 64; i++) {
187  qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][ff_zigzag_direct[i]];
188  qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][ff_zigzag_direct[i]];
189  }
190  }
191 }
192 
193 static int is_slice_short(const AVCodecContext *avctx, AVDXVAContext *ctx)
194 {
195  assert(DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 1 ||
196  DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 2);
197  return DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 2;
198 }
199 
200 static void fill_slice_short(DXVA_Slice_H264_Short *slice,
201  unsigned position, unsigned size)
202 {
203  memset(slice, 0, sizeof(*slice));
204  slice->BSNALunitDataLocation = position;
205  slice->SliceBytesInBuffer = size;
206  slice->wBadSliceChopping = 0;
207 }
208 
209 static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index)
210 {
211  int i;
212  for (i = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) {
213  if ((pp->RefFrameList[i].bPicEntry & 0x7f) == surface_index)
214  return i;
215  }
216  return 0x7f;
217 }
218 
219 static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,
220  const DXVA_PicParams_H264 *pp, unsigned position, unsigned size)
221 {
222  const H264Context *h = avctx->priv_data;
223  H264SliceContext *sl = &h->slice_ctx[0];
224  AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
225  unsigned list;
226 
227  memset(slice, 0, sizeof(*slice));
228  slice->BSNALunitDataLocation = position;
229  slice->SliceBytesInBuffer = size;
230  slice->wBadSliceChopping = 0;
231 
232  slice->first_mb_in_slice = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x;
233  slice->NumMbsForSlice = 0; /* XXX it is set once we have all slices */
234  slice->BitOffsetToSliceData = get_bits_count(&sl->gb) - 8;
235  slice->slice_type = ff_h264_get_slice_type(sl);
236  if (sl->slice_type_fixed)
237  slice->slice_type += 5;
238  slice->luma_log2_weight_denom = sl->pwt.luma_log2_weight_denom;
239  slice->chroma_log2_weight_denom = sl->pwt.chroma_log2_weight_denom;
240  if (sl->list_count > 0)
241  slice->num_ref_idx_l0_active_minus1 = sl->ref_count[0] - 1;
242  if (sl->list_count > 1)
243  slice->num_ref_idx_l1_active_minus1 = sl->ref_count[1] - 1;
244  slice->slice_alpha_c0_offset_div2 = sl->slice_alpha_c0_offset / 2;
245  slice->slice_beta_offset_div2 = sl->slice_beta_offset / 2;
246  slice->Reserved8Bits = 0;
247 
248  for (list = 0; list < 2; list++) {
249  unsigned i;
250  for (i = 0; i < FF_ARRAY_ELEMS(slice->RefPicList[list]); i++) {
251  if (list < sl->list_count && i < sl->ref_count[list]) {
252  const H264Picture *r = sl->ref_list[list][i].parent;
253  unsigned plane;
254  unsigned index;
255  if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)
256  index = ff_dxva2_get_surface_index(avctx, ctx, r->f);
257  else
259  fill_picture_entry(&slice->RefPicList[list][i], index,
261  for (plane = 0; plane < 3; plane++) {
262  int w, o;
263  if (plane == 0 && sl->pwt.luma_weight_flag[list]) {
264  w = sl->pwt.luma_weight[i][list][0];
265  o = sl->pwt.luma_weight[i][list][1];
266  } else if (plane >= 1 && sl->pwt.chroma_weight_flag[list]) {
267  w = sl->pwt.chroma_weight[i][list][plane-1][0];
268  o = sl->pwt.chroma_weight[i][list][plane-1][1];
269  } else {
270  w = 1 << (plane == 0 ? sl->pwt.luma_log2_weight_denom :
272  o = 0;
273  }
274  slice->Weights[list][i][plane][0] = w;
275  slice->Weights[list][i][plane][1] = o;
276  }
277  } else {
278  unsigned plane;
279  slice->RefPicList[list][i].bPicEntry = 0xff;
280  for (plane = 0; plane < 3; plane++) {
281  slice->Weights[list][i][plane][0] = 0;
282  slice->Weights[list][i][plane][1] = 0;
283  }
284  }
285  }
286  }
287  slice->slice_qs_delta = 0; /* XXX not implemented by FFmpeg */
288  slice->slice_qp_delta = sl->qscale - h->ps.pps->init_qp;
289  slice->redundant_pic_cnt = sl->redundant_pic_count;
290  if (sl->slice_type == AV_PICTURE_TYPE_B)
291  slice->direct_spatial_mv_pred_flag = sl->direct_spatial_mv_pred;
292  slice->cabac_init_idc = h->ps.pps->cabac ? sl->cabac_init_idc : 0;
293  if (sl->deblocking_filter < 2)
294  slice->disable_deblocking_filter_idc = 1 - sl->deblocking_filter;
295  else
296  slice->disable_deblocking_filter_idc = sl->deblocking_filter;
297  slice->slice_id = h->current_slice - 1;
298 }
299 
303 {
304  const H264Context *h = avctx->priv_data;
305  const unsigned mb_count = h->mb_width * h->mb_height;
306  AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
307  const H264Picture *current_picture = h->cur_pic_ptr;
308  struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
309  DXVA_Slice_H264_Short *slice = NULL;
310  void *dxva_data_ptr = NULL;
311  uint8_t *dxva_data, *current, *end;
312  unsigned dxva_size = 0;
313  void *slice_data;
314  unsigned slice_size;
315  unsigned padding;
316  unsigned i;
317  unsigned type;
318 
319  /* Create an annex B bitstream buffer with only slice NAL and finalize slice */
320 #if CONFIG_D3D11VA
321  if (ff_dxva2_is_d3d11(avctx)) {
322  type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
323  if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
325  type,
326  &dxva_size, &dxva_data_ptr)))
327  return -1;
328  }
329 #endif
330 #if CONFIG_DXVA2
331  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
332  type = DXVA2_BitStreamDateBufferType;
333  if (FAILED(IDirectXVideoDecoder_GetBuffer(DXVA2_CONTEXT(ctx)->decoder,
334  type,
335  &dxva_data_ptr, &dxva_size)))
336  return -1;
337  }
338 #endif
339 
340  dxva_data = dxva_data_ptr;
341  current = dxva_data;
342  end = dxva_data + dxva_size;
343 
344  for (i = 0; i < ctx_pic->slice_count; i++) {
345  static const uint8_t start_code[] = { 0, 0, 1 };
346  static const unsigned start_code_size = sizeof(start_code);
347  unsigned position, size;
348 
349  assert(offsetof(DXVA_Slice_H264_Short, BSNALunitDataLocation) ==
350  offsetof(DXVA_Slice_H264_Long, BSNALunitDataLocation));
351  assert(offsetof(DXVA_Slice_H264_Short, SliceBytesInBuffer) ==
352  offsetof(DXVA_Slice_H264_Long, SliceBytesInBuffer));
353 
354  if (is_slice_short(avctx, ctx))
355  slice = &ctx_pic->slice_short[i];
356  else
357  slice = (DXVA_Slice_H264_Short*)&ctx_pic->slice_long[i];
358 
359  position = slice->BSNALunitDataLocation;
360  size = slice->SliceBytesInBuffer;
361  if (start_code_size + size > end - current) {
362  av_log(avctx, AV_LOG_ERROR, "Failed to build bitstream");
363  break;
364  }
365 
366  slice->BSNALunitDataLocation = current - dxva_data;
367  slice->SliceBytesInBuffer = start_code_size + size;
368 
369  if (!is_slice_short(avctx, ctx)) {
370  DXVA_Slice_H264_Long *slice_long = (DXVA_Slice_H264_Long*)slice;
371  if (i < ctx_pic->slice_count - 1)
372  slice_long->NumMbsForSlice =
373  slice_long[1].first_mb_in_slice - slice_long[0].first_mb_in_slice;
374  else
375  slice_long->NumMbsForSlice = mb_count - slice_long->first_mb_in_slice;
376  }
377 
378  memcpy(current, start_code, start_code_size);
379  current += start_code_size;
380 
381  memcpy(current, &ctx_pic->bitstream[position], size);
382  current += size;
383  }
384  padding = FFMIN(128 - ((current - dxva_data) & 127), end - current);
385  if (slice && padding > 0) {
386  memset(current, 0, padding);
387  current += padding;
388 
389  slice->SliceBytesInBuffer += padding;
390  }
391 #if CONFIG_D3D11VA
392  if (ff_dxva2_is_d3d11(avctx))
393  if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
394  return -1;
395 #endif
396 #if CONFIG_DXVA2
397  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
398  if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type)))
399  return -1;
400 #endif
401  if (i < ctx_pic->slice_count)
402  return -1;
403 
404 #if CONFIG_D3D11VA
405  if (ff_dxva2_is_d3d11(avctx)) {
406  D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
407  memset(dsc11, 0, sizeof(*dsc11));
408  dsc11->BufferType = type;
409  dsc11->DataSize = current - dxva_data;
410  dsc11->NumMBsInBuffer = mb_count;
411 
412  type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
413 
414  av_assert0((dsc11->DataSize & 127) == 0);
415  }
416 #endif
417 #if CONFIG_DXVA2
418  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
419  DXVA2_DecodeBufferDesc *dsc2 = bs;
420  memset(dsc2, 0, sizeof(*dsc2));
421  dsc2->CompressedBufferType = type;
422  dsc2->DataSize = current - dxva_data;
423  dsc2->NumMBsInBuffer = mb_count;
424 
425  type = DXVA2_SliceControlBufferType;
426 
427  av_assert0((dsc2->DataSize & 127) == 0);
428  }
429 #endif
430 
431  if (is_slice_short(avctx, ctx)) {
432  slice_data = ctx_pic->slice_short;
433  slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_short);
434  } else {
435  slice_data = ctx_pic->slice_long;
436  slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_long);
437  }
438  return ff_dxva2_commit_buffer(avctx, ctx, sc,
439  type,
440  slice_data, slice_size, mb_count);
441 }
442 
443 
445  av_unused const uint8_t *buffer,
446  av_unused uint32_t size)
447 {
448  const H264Context *h = avctx->priv_data;
449  AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
450  struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->hwaccel_picture_private;
451 
452  if (!DXVA_CONTEXT_VALID(avctx, ctx))
453  return -1;
454  assert(ctx_pic);
455 
456  /* Fill up DXVA_PicParams_H264 */
457  fill_picture_parameters(avctx, ctx, h, &ctx_pic->pp);
458 
459  /* Fill up DXVA_Qmatrix_H264 */
460  fill_scaling_lists(avctx, ctx, h, &ctx_pic->qm);
461 
462  ctx_pic->slice_count = 0;
463  ctx_pic->bitstream_size = 0;
464  ctx_pic->bitstream = NULL;
465  return 0;
466 }
467 
469  const uint8_t *buffer,
470  uint32_t size)
471 {
472  const H264Context *h = avctx->priv_data;
473  const H264SliceContext *sl = &h->slice_ctx[0];
474  AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
475  const H264Picture *current_picture = h->cur_pic_ptr;
476  struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
477  unsigned position;
478 
479  if (ctx_pic->slice_count >= MAX_SLICES)
480  return -1;
481 
482  if (!ctx_pic->bitstream)
483  ctx_pic->bitstream = buffer;
484  ctx_pic->bitstream_size += size;
485 
486  position = buffer - ctx_pic->bitstream;
487  if (is_slice_short(avctx, ctx))
488  fill_slice_short(&ctx_pic->slice_short[ctx_pic->slice_count],
489  position, size);
490  else
491  fill_slice_long(avctx, &ctx_pic->slice_long[ctx_pic->slice_count],
492  &ctx_pic->pp, position, size);
493  ctx_pic->slice_count++;
494 
496  ctx_pic->pp.wBitFields &= ~(1 << 15); /* Set IntraPicFlag to 0 */
497  return 0;
498 }
499 
501 {
502  H264Context *h = avctx->priv_data;
503  H264SliceContext *sl = &h->slice_ctx[0];
504  struct dxva2_picture_context *ctx_pic =
505  h->cur_pic_ptr->hwaccel_picture_private;
506  int ret;
507 
508  if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
509  return -1;
510  ret = ff_dxva2_common_end_frame(avctx, h->cur_pic_ptr->f,
511  &ctx_pic->pp, sizeof(ctx_pic->pp),
512  &ctx_pic->qm, sizeof(ctx_pic->qm),
514  if (!ret)
515  ff_h264_draw_horiz_band(h, sl, 0, h->avctx->height);
516  return ret;
517 }
518 
519 #if CONFIG_H264_DXVA2_HWACCEL
521  .p.name = "h264_dxva2",
522  .p.type = AVMEDIA_TYPE_VIDEO,
523  .p.id = AV_CODEC_ID_H264,
524  .p.pix_fmt = AV_PIX_FMT_DXVA2_VLD,
525  .init = ff_dxva2_decode_init,
526  .uninit = ff_dxva2_decode_uninit,
527  .start_frame = dxva2_h264_start_frame,
528  .decode_slice = dxva2_h264_decode_slice,
529  .end_frame = dxva2_h264_end_frame,
530  .frame_params = ff_dxva2_common_frame_params,
531  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
532  .priv_data_size = sizeof(FFDXVASharedContext),
533 };
534 #endif
535 
536 #if CONFIG_H264_D3D11VA_HWACCEL
538  .p.name = "h264_d3d11va",
539  .p.type = AVMEDIA_TYPE_VIDEO,
540  .p.id = AV_CODEC_ID_H264,
541  .p.pix_fmt = AV_PIX_FMT_D3D11VA_VLD,
542  .init = ff_dxva2_decode_init,
543  .uninit = ff_dxva2_decode_uninit,
544  .start_frame = dxva2_h264_start_frame,
545  .decode_slice = dxva2_h264_decode_slice,
546  .end_frame = dxva2_h264_end_frame,
547  .frame_params = ff_dxva2_common_frame_params,
548  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
549  .priv_data_size = sizeof(FFDXVASharedContext),
550 };
551 #endif
552 
553 #if CONFIG_H264_D3D11VA2_HWACCEL
555  .p.name = "h264_d3d11va2",
556  .p.type = AVMEDIA_TYPE_VIDEO,
557  .p.id = AV_CODEC_ID_H264,
558  .p.pix_fmt = AV_PIX_FMT_D3D11,
559  .init = ff_dxva2_decode_init,
560  .uninit = ff_dxva2_decode_uninit,
561  .start_frame = dxva2_h264_start_frame,
562  .decode_slice = dxva2_h264_decode_slice,
563  .end_frame = dxva2_h264_end_frame,
564  .frame_params = ff_dxva2_common_frame_params,
565  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
566  .priv_data_size = sizeof(FFDXVASharedContext),
567 };
568 #endif
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
fill_slice_long
static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice, const DXVA_PicParams_H264 *pp, unsigned position, unsigned size)
Definition: dxva2_h264.c:219
r
const char * r
Definition: vf_curves.c:126
H264Picture::f
AVFrame * f
Definition: h264dec.h:107
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
fill_picture_parameters
static void fill_picture_parameters(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_PicParams_H264 *pp)
Definition: dxva2_h264.c:51
av_unused
#define av_unused
Definition: attributes.h:131
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:218
w
uint8_t w
Definition: llviddspenc.c:38
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:261
ff_dxva2_common_end_frame
int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame, const void *pp, unsigned pp_size, const void *qm, unsigned qm_size, int(*commit_bs_si)(AVCodecContext *, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *slice))
Definition: dxva2.c:886
fill_picture_entry
static void fill_picture_entry(DXVA_PicEntry_H264 *pic, unsigned index, unsigned flag)
Definition: dxva2_h264.c:44
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:247
dxva2_picture_context::pp
DXVA_PicParams_H264 pp
Definition: dxva2_h264.c:35
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
fill_slice_short
static void fill_slice_short(DXVA_Slice_H264_Short *slice, unsigned position, unsigned size)
Definition: dxva2_h264.c:200
mpegutils.h
H264SliceContext::mb_x
int mb_x
Definition: h264dec.h:224
H264SliceContext
Definition: h264dec.h:171
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
FFHWAccel
Definition: hwaccel_internal.h:34
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
H264SliceContext::deblocking_filter
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
Definition: h264dec.h:187
H264PredWeightTable::luma_log2_weight_denom
int luma_log2_weight_denom
Definition: h264_parse.h:72
H264SliceContext::direct_spatial_mv_pred
int direct_spatial_mv_pred
Definition: h264dec.h:245
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
H264PredWeightTable::chroma_weight
int chroma_weight[48][2][2][2]
Definition: h264_parse.h:78
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
DXVA2_CONTEXT
#define DXVA2_CONTEXT(ctx)
Definition: dxva2_internal.h:102
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:127
H264PredWeightTable::chroma_log2_weight_denom
int chroma_log2_weight_denom
Definition: h264_parse.h:73
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
DXVA_CONTEXT
#define DXVA_CONTEXT(avctx)
Definition: dxva2_internal.h:99
H264PredWeightTable::chroma_weight_flag
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
Definition: h264_parse.h:75
h264data.h
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
H264SliceContext::slice_alpha_c0_offset
int slice_alpha_c0_offset
Definition: h264dec.h:188
H264PredWeightTable::luma_weight
int luma_weight[48][2][2]
Definition: h264_parse.h:77
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:177
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
get_refpic_index
static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index)
Definition: dxva2_h264.c:209
ff_h264_draw_horiz_band
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:101
dxva2_internal.h
if
if(ret)
Definition: filter_design.txt:179
NULL
#define NULL
Definition: coverity.c:32
ff_dxva2_decode_init
int ff_dxva2_decode_init(AVCodecContext *avctx)
Definition: dxva2.c:655
hwaccel_internal.h
SPS
Sequence parameter set.
Definition: h264_ps.h:44
H264Ref::parent
const H264Picture * parent
Definition: h264dec.h:168
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:283
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
PPS
Picture parameter set.
Definition: h264_ps.h:110
list
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 list
Definition: filter_design.txt:25
FFDXVASharedContext
Definition: dxva2_internal.h:67
H264SliceContext::qscale
int qscale
Definition: h264dec.h:181
dxva2_picture_context
Definition: dxva2_h264.c:34
ff_h264_d3d11va2_hwaccel
const struct FFHWAccel ff_h264_d3d11va2_hwaccel
ff_h264_d3d11va_hwaccel
const struct FFHWAccel ff_h264_d3d11va_hwaccel
FIELD_OR_MBAFF_PICTURE
#define FIELD_OR_MBAFF_PICTURE(h)
Definition: h264dec.h:84
h264_ps.h
index
int index
Definition: gxfenc.c:89
commit_bitstream_and_slice_buffer
static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *sc)
Definition: dxva2_h264.c:300
dxva2_picture_context::slice_long
DXVA_Slice_H264_Long slice_long[MAX_SLICES]
Definition: dxva2_h264.c:39
H264SliceContext::redundant_pic_count
int redundant_pic_count
Definition: h264dec.h:238
ff_zigzag_scan
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:109
dxva2_picture_context::slice_count
unsigned slice_count
Definition: dxva2_h264.c:37
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
H264SliceContext::pwt
H264PredWeightTable pwt
Definition: h264dec.h:191
size
int size
Definition: twinvq_data.h:10344
dxva2_h264_end_frame
static int dxva2_h264_end_frame(AVCodecContext *avctx)
Definition: dxva2_h264.c:500
AVDXVAContext
Definition: dxva2_internal.h:58
H264SliceContext::mb_y
int mb_y
Definition: h264dec.h:224
DECODER_BUFFER_DESC
void DECODER_BUFFER_DESC
Definition: dxva2_internal.h:56
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:333
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2135
dxva2_picture_context::slice_short
DXVA_Slice_H264_Short slice_short[MAX_SLICES]
Definition: dxva2_h264.c:38
flag
#define flag(name)
Definition: cbs_av1.c:466
is_slice_short
static int is_slice_short(const AVCodecContext *avctx, AVDXVAContext *ctx)
Definition: dxva2_h264.c:193
h264dec.h
D3D11VA_CONTEXT
#define D3D11VA_CONTEXT(ctx)
Definition: dxva2_internal.h:101
H264Context
H264Context.
Definition: h264dec.h:331
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG
#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG
Work around for Direct3D11 and old UVD/UVD+ ATI video cards.
Definition: d3d11va.h:48
ff_dxva2_commit_buffer
int ff_dxva2_commit_buffer(AVCodecContext *avctx, AVDXVAContext *ctx, DECODER_BUFFER_DESC *dsc, unsigned type, const void *data, unsigned size, unsigned mb_count)
Definition: dxva2.c:797
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:262
ff_dxva2_get_surface_index
unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx, const AVDXVAContext *ctx, const AVFrame *frame)
Definition: dxva2.c:770
ff_dxva2_common_frame_params
int ff_dxva2_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: dxva2.c:592
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
dxva2_picture_context::slice
DXVA_SliceInfo slice[MAX_SLICES]
Definition: dxva2_mpeg2.c:37
dxva2_picture_context::bitstream
const uint8_t * bitstream
Definition: dxva2_h264.c:40
H264SliceContext::slice_beta_offset
int slice_beta_offset
Definition: h264dec.h:189
AVCodecContext
main external API structure.
Definition: avcodec.h:441
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:32
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:127
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_dxva2_is_d3d11
int ff_dxva2_is_d3d11(const AVCodecContext *avctx)
Definition: dxva2.c:1051
H264Picture
Definition: h264dec.h:106
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:263
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_dxva2_decode_uninit
int ff_dxva2_decode_uninit(AVCodecContext *avctx)
Definition: dxva2.c:730
dxva2_h264_start_frame
static int dxva2_h264_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: dxva2_h264.c:444
ff_h264_dxva2_hwaccel
const struct FFHWAccel ff_h264_dxva2_hwaccel
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference for hardware accelerator private data.
Definition: h264dec.h:122
FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO
#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO
Work around for Direct3D11 and old Intel GPUs with ClearVideo interface.
Definition: d3d11va.h:49
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:173
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
fill_scaling_lists
static void fill_scaling_lists(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
Definition: dxva2_h264.c:167
ff_h264_get_slice_type
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:2159
h
h
Definition: vp9dsp_template.c:2038
H264SliceContext::cabac_init_idc
int cabac_init_idc
Definition: h264dec.h:313
H264PredWeightTable::luma_weight_flag
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
Definition: h264_parse.h:74
dxva2_picture_context::qm
DXVA_Qmatrix_H264 qm
Definition: dxva2_h264.c:36
H264SliceContext::slice_type_fixed
int slice_type_fixed
Definition: h264dec.h:179
dxva2_h264_decode_slice
static int dxva2_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: dxva2_h264.c:468
H264Ref::reference
int reference
Definition: h264dec.h:164
dxva2_picture_context::bitstream_size
unsigned bitstream_size
Definition: dxva2_h264.c:41