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