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),
60  h->picture_structure == PICT_BOTTOM_FIELD);
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);
86  if (r->reference & PICT_BOTTOM_FIELD)
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;
134  if ((h->picture_structure & PICT_BOTTOM_FIELD) &&
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
256  fill_picture_entry(&slice->RefPicList[list][i], index,
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,
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);
447  struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->hwaccel_picture_private;
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 =
502  h->cur_pic_ptr->hwaccel_picture_private;
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
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:39
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:216
r
const char * r
Definition: vf_curves.c:116
H264Picture::f
AVFrame * f
Definition: h264dec.h:130
ff_h264_d3d11va2_hwaccel
const AVHWAccel ff_h264_d3d11va2_hwaccel
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
fill_picture_parameters
static void fill_picture_parameters(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_PicParams_H264 *pp)
Definition: dxva2_h264.c:48
av_unused
#define av_unused
Definition: attributes.h:131
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:186
index
fg index
Definition: ffmpeg_filter.c:170
w
uint8_t w
Definition: llviddspenc.c:39
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:274
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:41
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:229
dxva2_picture_context::pp
DXVA_PicParams_H264 pp
Definition: dxva2_h264.c:32
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
fill_slice_short
static void fill_slice_short(DXVA_Slice_H264_Short *slice, unsigned position, unsigned size)
Definition: dxva2_h264.c:197
mpegutils.h
H264SliceContext::mb_x
int mb_x
Definition: h264dec.h:237
H264SliceContext
Definition: h264dec.h:184
AVHWAccel
Definition: avcodec.h:2438
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:330
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:200
H264PredWeightTable::luma_log2_weight_denom
int luma_log2_weight_denom
Definition: h264_parse.h:33
H264SliceContext::direct_spatial_mv_pred
int direct_spatial_mv_pred
Definition: h264dec.h:258
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
H264PredWeightTable::chroma_weight
int chroma_weight[48][2][2][2]
Definition: h264_parse.h:39
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:137
H264PredWeightTable::chroma_log2_weight_denom
int chroma_log2_weight_denom
Definition: h264_parse.h:34
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:36
h264data.h
H264Ref::parent
H264Picture * parent
Definition: h264dec.h:181
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
H264SliceContext::slice_alpha_c0_offset
int slice_alpha_c0_offset
Definition: h264dec.h:201
H264PredWeightTable::luma_weight
int luma_weight[48][2][2]
Definition: h264_parse.h:38
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:190
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
get_refpic_index
static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index)
Definition: dxva2_h264.c:206
ff_h264_draw_horiz_band
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:103
ff_h264_d3d11va_hwaccel
const AVHWAccel ff_h264_d3d11va_hwaccel
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
SPS
Sequence parameter set.
Definition: h264_ps.h:44
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:278
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
PPS
Picture parameter set.
Definition: h264_ps.h:111
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:194
dxva2_picture_context
Definition: dxva2_h264.c:31
FIELD_OR_MBAFF_PICTURE
#define FIELD_OR_MBAFF_PICTURE(h)
Definition: h264dec.h:92
h264_ps.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
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:297
dxva2_picture_context::slice_long
DXVA_Slice_H264_Long slice_long[MAX_SLICES]
Definition: dxva2_h264.c:36
H264SliceContext::redundant_pic_count
int redundant_pic_count
Definition: h264dec.h:251
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:34
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
H264SliceContext::pwt
H264PredWeightTable pwt
Definition: h264dec.h:204
size
int size
Definition: twinvq_data.h:10344
dxva2_h264_end_frame
static int dxva2_h264_end_frame(AVCodecContext *avctx)
Definition: dxva2_h264.c:497
AVDXVAContext
Definition: dxva2_internal.h:58
H264SliceContext::mb_y
int mb_y
Definition: h264dec.h:237
DECODER_BUFFER_DESC
void DECODER_BUFFER_DESC
Definition: dxva2_internal.h:56
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:313
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2444
dxva2_picture_context::slice_short
DXVA_Slice_H264_Short slice_short[MAX_SLICES]
Definition: dxva2_h264.c:35
flag
#define flag(name)
Definition: cbs_av1.c:553
is_slice_short
static int is_slice_short(const AVCodecContext *avctx, AVDXVAContext *ctx)
Definition: dxva2_h264.c:190
h264dec.h
D3D11VA_CONTEXT
#define D3D11VA_CONTEXT(ctx)
Definition: dxva2_internal.h:101
i
int i
Definition: input.c:407
H264Context
H264Context.
Definition: h264dec.h:344
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
uint8_t
uint8_t
Definition: audio_convert.c:194
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:746
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:275
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:34
dxva2_picture_context::bitstream
const uint8_t * bitstream
Definition: dxva2_h264.c:37
H264SliceContext::slice_beta_offset
int slice_beta_offset
Definition: h264dec.h:202
AVCodecContext
main external API structure.
Definition: avcodec.h:536
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:29
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:148
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
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:129
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:276
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:441
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
hardware accelerator private data
Definition: h264dec.h:143
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:563
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:186
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
fill_scaling_lists
static void fill_scaling_lists(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
Definition: dxva2_h264.c:164
ff_h264_dxva2_hwaccel
const AVHWAccel ff_h264_dxva2_hwaccel
ff_h264_get_slice_type
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:2225
h
h
Definition: vp9dsp_template.c:2038
H264SliceContext::cabac_init_idc
int cabac_init_idc
Definition: h264dec.h:327
H264PredWeightTable::luma_weight_flag
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
Definition: h264_parse.h:35
dxva2_picture_context::qm
DXVA_Qmatrix_H264 qm
Definition: dxva2_h264.c:33
H264SliceContext::slice_type_fixed
int slice_type_fixed
Definition: h264dec.h:192
dxva2_h264_decode_slice
static int dxva2_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: dxva2_h264.c:465
H264Ref::reference
int reference
Definition: h264dec.h:177
dxva2_picture_context::bitstream_size
unsigned bitstream_size
Definition: dxva2_h264.c:38