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