FFmpeg
dxva2_vc1.c
Go to the documentation of this file.
1 /*
2  * DXVA2 WMV3/VC-1 HW acceleration.
3  *
4  * copyright (c) 2010 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 "dxva2_internal.h"
26 #include "mpegutils.h"
27 #include "mpegvideodec.h"
28 #include "vc1.h"
29 #include "vc1data.h"
30 
31 #define MAX_SLICES 1024
32 
33 struct dxva2_picture_context {
34  DXVA_PictureParameters pp;
35  unsigned slice_count;
36  DXVA_SliceInfo slice[MAX_SLICES];
37 
38  const uint8_t *bitstream;
39  unsigned bitstream_size;
40 };
41 
42 static void fill_picture_parameters(AVCodecContext *avctx,
43  AVDXVAContext *ctx, const VC1Context *v,
44  DXVA_PictureParameters *pp)
45 {
46  const MpegEncContext *s = &v->s;
47  const Picture *current_picture = s->current_picture_ptr;
48  int intcomp = 0;
49 
50  // determine if intensity compensation is needed
51  if (s->pict_type == AV_PICTURE_TYPE_P) {
52  if ((v->fcm == ILACE_FRAME && v->intcomp) || (v->fcm != ILACE_FRAME && v->mv_mode == MV_PMODE_INTENSITY_COMP)) {
53  if (v->lumscale != 32 || v->lumshift != 0 || (s->picture_structure != PICT_FRAME && (v->lumscale2 != 32 || v->lumshift2 != 0)))
54  intcomp = 1;
55  }
56  }
57 
58  memset(pp, 0, sizeof(*pp));
59  pp->wDecodedPictureIndex =
60  pp->wDeblockedPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, current_picture->f);
61  if (s->pict_type != AV_PICTURE_TYPE_I && !v->bi_type)
62  pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->last_picture.f);
63  else
64  pp->wForwardRefPictureIndex = 0xffff;
65  if (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type)
66  pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->next_picture.f);
67  else
68  pp->wBackwardRefPictureIndex = 0xffff;
69  if (v->profile == PROFILE_ADVANCED) {
70  /* It is the cropped width/height -1 of the frame */
71  pp->wPicWidthInMBminus1 = avctx->width - 1;
72  pp->wPicHeightInMBminus1= avctx->height - 1;
73  } else {
74  /* It is the coded width/height in macroblock -1 of the frame */
75  pp->wPicWidthInMBminus1 = s->mb_width - 1;
76  pp->wPicHeightInMBminus1= s->mb_height - 1;
77  }
78  pp->bMacroblockWidthMinus1 = 15;
79  pp->bMacroblockHeightMinus1 = 15;
80  pp->bBlockWidthMinus1 = 7;
81  pp->bBlockHeightMinus1 = 7;
82  pp->bBPPminus1 = 7;
83  if (s->picture_structure & PICT_TOP_FIELD)
84  pp->bPicStructure |= 0x01;
85  if (s->picture_structure & PICT_BOTTOM_FIELD)
86  pp->bPicStructure |= 0x02;
87  pp->bSecondField = v->interlace && v->fcm == ILACE_FIELD && v->second_field;
88  pp->bPicIntra = s->pict_type == AV_PICTURE_TYPE_I || v->bi_type;
89  pp->bPicBackwardPrediction = s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type;
90  pp->bBidirectionalAveragingMode = (1 << 7) |
91  ((DXVA_CONTEXT_CFG_INTRARESID(avctx, ctx) != 0) << 6) |
92  ((DXVA_CONTEXT_CFG_RESIDACCEL(avctx, ctx) != 0) << 5) |
93  (intcomp << 4) |
94  ((v->profile == PROFILE_ADVANCED) << 3);
95  pp->bMVprecisionAndChromaRelation = ((v->mv_mode == MV_PMODE_1MV_HPEL_BILIN) << 3) |
96  (1 << 2) |
97  (0 << 1) |
98  (!s->quarter_sample );
99  pp->bChromaFormat = v->chromaformat;
100  DXVA_CONTEXT_REPORT_ID(avctx, ctx)++;
101  if (DXVA_CONTEXT_REPORT_ID(avctx, ctx) >= (1 << 16))
102  DXVA_CONTEXT_REPORT_ID(avctx, ctx) = 1;
103  pp->bPicScanFixed = DXVA_CONTEXT_REPORT_ID(avctx, ctx) >> 8;
104  pp->bPicScanMethod = DXVA_CONTEXT_REPORT_ID(avctx, ctx) & 0xff;
105  pp->bPicReadbackRequests = 0;
106  pp->bRcontrol = v->rnd;
107  pp->bPicSpatialResid8 = (v->panscanflag << 7) |
108  (v->refdist_flag << 6) |
109  (s->loop_filter << 5) |
110  (v->fastuvmc << 4) |
111  (v->extended_mv << 3) |
112  (v->dquant << 1) |
113  (v->vstransform );
114  pp->bPicOverflowBlocks = (v->quantizer_mode << 6) |
115  (v->multires << 5) |
116  (v->resync_marker << 4) |
117  (v->rangered << 3) |
118  (s->max_b_frames );
119  pp->bPicExtrapolation = (!v->interlace || v->fcm == PROGRESSIVE) ? 1 : 2;
120  pp->bPicDeblocked = ((!pp->bPicBackwardPrediction && v->overlap) << 6) |
121  ((v->profile != PROFILE_ADVANCED && v->rangeredfrm) << 5) |
122  (s->loop_filter << 1);
123  pp->bPicDeblockConfined = (v->postprocflag << 7) |
124  (v->broadcast << 6) |
125  (v->interlace << 5) |
126  (v->tfcntrflag << 4) |
127  (v->finterpflag << 3) |
128  ((s->pict_type != AV_PICTURE_TYPE_B) << 2) |
129  (v->psf << 1) |
130  (v->extended_dmv );
131  if (s->pict_type != AV_PICTURE_TYPE_I)
132  pp->bPic4MVallowed = v->mv_mode == MV_PMODE_MIXED_MV ||
133  (v->mv_mode == MV_PMODE_INTENSITY_COMP &&
134  v->mv_mode2 == MV_PMODE_MIXED_MV);
135  if (v->profile == PROFILE_ADVANCED)
136  pp->bPicOBMC = (v->range_mapy_flag << 7) |
137  (v->range_mapy << 4) |
138  (v->range_mapuv_flag << 3) |
139  (v->range_mapuv );
140  pp->bPicBinPB = 0;
141  pp->bMV_RPS = (v->fcm == ILACE_FIELD && pp->bPicBackwardPrediction) ? v->refdist + 9 : 0;
142  pp->bReservedBits = v->pq;
143  if (s->picture_structure == PICT_FRAME) {
144  if (intcomp) {
145  pp->wBitstreamFcodes = v->lumscale;
146  pp->wBitstreamPCEelements = v->lumshift;
147  } else {
148  pp->wBitstreamFcodes = 32;
149  pp->wBitstreamPCEelements = 0;
150  }
151  } else {
152  /* Syntax: (top_field_param << 8) | bottom_field_param */
153  if (intcomp) {
154  pp->wBitstreamFcodes = (v->lumscale << 8) | v->lumscale2;
155  pp->wBitstreamPCEelements = (v->lumshift << 8) | v->lumshift2;
156  } else {
157  pp->wBitstreamFcodes = (32 << 8) | 32;
158  pp->wBitstreamPCEelements = 0;
159  }
160  }
161  pp->bBitstreamConcealmentNeed = 0;
162  pp->bBitstreamConcealmentMethod = 0;
163 }
164 
165 static void fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice,
166  unsigned position, unsigned size)
167 {
168  const VC1Context *v = avctx->priv_data;
169  const MpegEncContext *s = &v->s;
170 
171  memset(slice, 0, sizeof(*slice));
172  slice->wHorizontalPosition = 0;
173  slice->wVerticalPosition = s->mb_y;
174  slice->dwSliceBitsInBuffer = 8 * size;
175  slice->dwSliceDataLocation = position;
176  slice->bStartCodeBitOffset = 0;
177  slice->bReservedBits = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;
178  slice->wMBbitOffset = v->p_frame_skipped ? 0xffff : get_bits_count(&s->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
179  /* XXX We store the index of the first MB and it will be fixed later */
180  slice->wNumberMBsInSlice = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
181  slice->wQuantizerScaleCode = v->pq;
182  slice->wBadSliceChopping = 0;
183 }
184 
185 static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
186  DECODER_BUFFER_DESC *bs,
187  DECODER_BUFFER_DESC *sc)
188 {
189  const VC1Context *v = avctx->priv_data;
190  AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
191  const MpegEncContext *s = &v->s;
192  struct dxva2_picture_context *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;
193 
194  static const uint8_t start_code[] = { 0, 0, 1, 0x0d };
195  const unsigned start_code_size = avctx->codec_id == AV_CODEC_ID_VC1 ? sizeof(start_code) : 0;
196  const unsigned mb_count = s->mb_width * (s->mb_height >> v->field_mode);
197  DXVA_SliceInfo *slice = NULL;
198  void *dxva_data_ptr;
199  uint8_t *dxva_data, *current, *end;
200  unsigned dxva_size;
201  unsigned padding;
202  unsigned i;
203  unsigned type;
204 
205 #if CONFIG_D3D11VA
206  if (ff_dxva2_is_d3d11(avctx)) {
207  type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
208  if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
209  D3D11VA_CONTEXT(ctx)->decoder,
210  type,
211  &dxva_size, &dxva_data_ptr)))
212  return -1;
213  }
214 #endif
215 #if CONFIG_DXVA2
216  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
217  type = DXVA2_BitStreamDateBufferType;
218  if (FAILED(IDirectXVideoDecoder_GetBuffer(DXVA2_CONTEXT(ctx)->decoder,
219  type,
220  &dxva_data_ptr, &dxva_size)))
221  return -1;
222  }
223 #endif
224 
225  dxva_data = dxva_data_ptr;
226  current = dxva_data;
227  end = dxva_data + dxva_size;
228 
229  for (i = 0; i < ctx_pic->slice_count; i++) {
230  unsigned position, size;
231  slice = &ctx_pic->slice[i];
232  position = slice->dwSliceDataLocation;
233  size = slice->dwSliceBitsInBuffer / 8;
234  if (start_code_size + size > end - current) {
235  av_log(avctx, AV_LOG_ERROR, "Failed to build bitstream");
236  break;
237  }
238  slice->dwSliceDataLocation = current - dxva_data;
239 
240  if (i < ctx_pic->slice_count - 1)
241  slice->wNumberMBsInSlice =
242  slice[1].wNumberMBsInSlice - slice[0].wNumberMBsInSlice;
243  else
244  slice->wNumberMBsInSlice =
245  mb_count - slice[0].wNumberMBsInSlice;
246 
247  /* write the appropriate frame, field or slice start code */
248  if (start_code_size) {
249  memcpy(current, start_code, start_code_size);
250  if (i == 0 && v->second_field)
251  current[3] = 0x0c;
252  else if (i > 0)
253  current[3] = 0x0b;
254 
255  current += start_code_size;
256  slice->dwSliceBitsInBuffer += start_code_size * 8;
257  }
258 
259  memcpy(current, &ctx_pic->bitstream[position], size);
260  current += size;
261  }
262  padding = FFMIN(128 - ((current - dxva_data) & 127), end - current);
263  if (slice && padding > 0) {
264  memset(current, 0, padding);
265  current += padding;
266  slice->dwSliceBitsInBuffer += padding * 8;
267  }
268 
269 #if CONFIG_D3D11VA
270  if (ff_dxva2_is_d3d11(avctx))
271  if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
272  return -1;
273 #endif
274 #if CONFIG_DXVA2
275  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
276  if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type)))
277  return -1;
278 #endif
279  if (i < ctx_pic->slice_count)
280  return -1;
281 
282 #if CONFIG_D3D11VA
283  if (ff_dxva2_is_d3d11(avctx)) {
284  D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
285  memset(dsc11, 0, sizeof(*dsc11));
286  dsc11->BufferType = type;
287  dsc11->DataSize = current - dxva_data;
288  dsc11->NumMBsInBuffer = mb_count;
289 
290  type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
291  }
292 #endif
293 #if CONFIG_DXVA2
294  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
295  DXVA2_DecodeBufferDesc *dsc2 = bs;
296  memset(dsc2, 0, sizeof(*dsc2));
297  dsc2->CompressedBufferType = type;
298  dsc2->DataSize = current - dxva_data;
299  dsc2->NumMBsInBuffer = mb_count;
300 
301  type = DXVA2_SliceControlBufferType;
302  }
303 #endif
304 
305  return ff_dxva2_commit_buffer(avctx, ctx, sc,
306  type,
307  ctx_pic->slice,
308  ctx_pic->slice_count * sizeof(*ctx_pic->slice),
309  mb_count);
310 }
311 
312 static int dxva2_vc1_start_frame(AVCodecContext *avctx,
313  av_unused const uint8_t *buffer,
314  av_unused uint32_t size)
315 {
316  const VC1Context *v = avctx->priv_data;
317  AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
318  struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;
319 
320  if (!DXVA_CONTEXT_VALID(avctx, ctx))
321  return -1;
322  assert(ctx_pic);
323 
324  fill_picture_parameters(avctx, ctx, v, &ctx_pic->pp);
325 
326  ctx_pic->slice_count = 0;
327  ctx_pic->bitstream_size = 0;
328  ctx_pic->bitstream = NULL;
329  return 0;
330 }
331 
332 static int dxva2_vc1_decode_slice(AVCodecContext *avctx,
333  const uint8_t *buffer,
334  uint32_t size)
335 {
336  const VC1Context *v = avctx->priv_data;
337  const Picture *current_picture = v->s.current_picture_ptr;
338  struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
339  unsigned position;
340 
341  if (ctx_pic->slice_count >= MAX_SLICES) {
342  avpriv_request_sample(avctx, "%d slices in dxva2",
343  ctx_pic->slice_count);
344  return -1;
345  }
346 
347  if (avctx->codec_id == AV_CODEC_ID_VC1 &&
348  size >= 4 && IS_MARKER(AV_RB32(buffer))) {
349  buffer += 4;
350  size -= 4;
351  }
352 
353  if (!ctx_pic->bitstream)
354  ctx_pic->bitstream = buffer;
355  ctx_pic->bitstream_size += size;
356 
357  position = buffer - ctx_pic->bitstream;
358  fill_slice(avctx, &ctx_pic->slice[ctx_pic->slice_count++], position, size);
359  return 0;
360 }
361 
362 static int dxva2_vc1_end_frame(AVCodecContext *avctx)
363 {
364  VC1Context *v = avctx->priv_data;
365  struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;
366  int ret;
367 
368  if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
369  return -1;
370 
371  ret = ff_dxva2_common_end_frame(avctx, v->s.current_picture_ptr->f,
372  &ctx_pic->pp, sizeof(ctx_pic->pp),
373  NULL, 0,
374  commit_bitstream_and_slice_buffer);
375  return ret;
376 }
377 
378 #if CONFIG_WMV3_DXVA2_HWACCEL
379 const AVHWAccel ff_wmv3_dxva2_hwaccel = {
380  .name = "wmv3_dxva2",
381  .type = AVMEDIA_TYPE_VIDEO,
382  .id = AV_CODEC_ID_WMV3,
383  .pix_fmt = AV_PIX_FMT_DXVA2_VLD,
384  .init = ff_dxva2_decode_init,
385  .uninit = ff_dxva2_decode_uninit,
386  .start_frame = dxva2_vc1_start_frame,
387  .decode_slice = dxva2_vc1_decode_slice,
388  .end_frame = dxva2_vc1_end_frame,
389  .frame_params = ff_dxva2_common_frame_params,
390  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
391  .priv_data_size = sizeof(FFDXVASharedContext),
392 };
393 #endif
394 
395 #if CONFIG_VC1_DXVA2_HWACCEL
396 const AVHWAccel ff_vc1_dxva2_hwaccel = {
397  .name = "vc1_dxva2",
398  .type = AVMEDIA_TYPE_VIDEO,
399  .id = AV_CODEC_ID_VC1,
400  .pix_fmt = AV_PIX_FMT_DXVA2_VLD,
401  .init = ff_dxva2_decode_init,
402  .uninit = ff_dxva2_decode_uninit,
403  .start_frame = dxva2_vc1_start_frame,
404  .decode_slice = dxva2_vc1_decode_slice,
405  .end_frame = dxva2_vc1_end_frame,
406  .frame_params = ff_dxva2_common_frame_params,
407  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
408  .priv_data_size = sizeof(FFDXVASharedContext),
409 };
410 #endif
411 
412 #if CONFIG_WMV3_D3D11VA_HWACCEL
413 const AVHWAccel ff_wmv3_d3d11va_hwaccel = {
414  .name = "wmv3_d3d11va",
415  .type = AVMEDIA_TYPE_VIDEO,
416  .id = AV_CODEC_ID_WMV3,
417  .pix_fmt = AV_PIX_FMT_D3D11VA_VLD,
418  .init = ff_dxva2_decode_init,
419  .uninit = ff_dxva2_decode_uninit,
420  .start_frame = dxva2_vc1_start_frame,
421  .decode_slice = dxva2_vc1_decode_slice,
422  .end_frame = dxva2_vc1_end_frame,
423  .frame_params = ff_dxva2_common_frame_params,
424  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
425  .priv_data_size = sizeof(FFDXVASharedContext),
426 };
427 #endif
428 
429 #if CONFIG_WMV3_D3D11VA2_HWACCEL
430 const AVHWAccel ff_wmv3_d3d11va2_hwaccel = {
431  .name = "wmv3_d3d11va2",
432  .type = AVMEDIA_TYPE_VIDEO,
433  .id = AV_CODEC_ID_WMV3,
434  .pix_fmt = AV_PIX_FMT_D3D11,
435  .init = ff_dxva2_decode_init,
436  .uninit = ff_dxva2_decode_uninit,
437  .start_frame = dxva2_vc1_start_frame,
438  .decode_slice = dxva2_vc1_decode_slice,
439  .end_frame = dxva2_vc1_end_frame,
440  .frame_params = ff_dxva2_common_frame_params,
441  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
442  .priv_data_size = sizeof(FFDXVASharedContext),
443 };
444 #endif
445 
446 #if CONFIG_VC1_D3D11VA_HWACCEL
447 const AVHWAccel ff_vc1_d3d11va_hwaccel = {
448  .name = "vc1_d3d11va",
449  .type = AVMEDIA_TYPE_VIDEO,
450  .id = AV_CODEC_ID_VC1,
451  .pix_fmt = AV_PIX_FMT_D3D11VA_VLD,
452  .init = ff_dxva2_decode_init,
453  .uninit = ff_dxva2_decode_uninit,
454  .start_frame = dxva2_vc1_start_frame,
455  .decode_slice = dxva2_vc1_decode_slice,
456  .end_frame = dxva2_vc1_end_frame,
457  .frame_params = ff_dxva2_common_frame_params,
458  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
459  .priv_data_size = sizeof(FFDXVASharedContext),
460 };
461 #endif
462 
463 #if CONFIG_VC1_D3D11VA2_HWACCEL
464 const AVHWAccel ff_vc1_d3d11va2_hwaccel = {
465  .name = "vc1_d3d11va2",
466  .type = AVMEDIA_TYPE_VIDEO,
467  .id = AV_CODEC_ID_VC1,
468  .pix_fmt = AV_PIX_FMT_D3D11,
469  .init = ff_dxva2_decode_init,
470  .uninit = ff_dxva2_decode_uninit,
471  .start_frame = dxva2_vc1_start_frame,
472  .decode_slice = dxva2_vc1_decode_slice,
473  .end_frame = dxva2_vc1_end_frame,
474  .frame_params = ff_dxva2_common_frame_params,
475  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
476  .priv_data_size = sizeof(FFDXVASharedContext),
477 };
478 #endif
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
VC1Context::lumscale2
uint8_t lumscale2
for interlaced field P picture
Definition: vc1.h:335
VC1Context
The VC1 Context.
Definition: vc1.h:173
PROGRESSIVE
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition: vc1.h:149
VC1Context::intcomp
int intcomp
Definition: vc1.h:334
VC1Context::overlap
int overlap
overlapped transforms in use
Definition: vc1.h:224
VC1Context::interlace
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:199
vc1.h
ILACE_FRAME
@ ILACE_FRAME
in the bitstream is reported as 10b
Definition: vc1.h:150
dxva2_vc1_start_frame
static int dxva2_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: dxva2_vc1.c:312
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:256
av_unused
#define av_unused
Definition: attributes.h:131
ff_wmv3_dxva2_hwaccel
const AVHWAccel ff_wmv3_dxva2_hwaccel
MV_PMODE_1MV_HPEL_BILIN
@ MV_PMODE_1MV_HPEL_BILIN
Definition: vc1.h:79
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:198
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
VC1Context::fastuvmc
int fastuvmc
Rounding of qpel vector to hpel ? (not in Simple)
Definition: vc1.h:220
MV_PMODE_INTENSITY_COMP
@ MV_PMODE_INTENSITY_COMP
Definition: vc1.h:83
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:247
dxva2_picture_context::pp
DXVA_PicParams_H264 pp
Definition: dxva2_h264.c:34
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
Picture
Picture.
Definition: mpegpicture.h:46
ff_wmv3_d3d11va_hwaccel
const AVHWAccel ff_wmv3_d3d11va_hwaccel
mpegutils.h
AVHWAccel
Definition: avcodec.h:2076
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
ILACE_FIELD
@ ILACE_FIELD
in the bitstream is reported as 11b
Definition: vc1.h:151
VC1Context::multires
int multires
frame-level RESPIC syntax element present
Definition: vc1.h:184
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
dxva2_vc1_end_frame
static int dxva2_vc1_end_frame(AVCodecContext *avctx)
Definition: dxva2_vc1.c:362
VC1Context::dquant
int dquant
How qscale varies with MBs, 2 bits (not in Simple)
Definition: vc1.h:222
VC1Context::refdist
int refdist
distance of the current picture from reference
Definition: vc1.h:352
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
DXVA2_CONTEXT
#define DXVA2_CONTEXT(ctx)
Definition: dxva2_internal.h:102
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:127
s
#define s(width, name)
Definition: cbs_vp9.c:256
VC1Context::range_mapuv_flag
uint8_t range_mapuv_flag
Definition: vc1.h:326
VC1Context::postprocflag
int postprocflag
Per-frame processing suggestion flag present.
Definition: vc1.h:197
DXVA_CONTEXT
#define DXVA_CONTEXT(avctx)
Definition: dxva2_internal.h:99
PROFILE_ADVANCED
@ PROFILE_ADVANCED
Definition: vc1_common.h:52
VC1Context::rangered
int rangered
RANGEREDFRM (range reduction) syntax element present at frame level.
Definition: vc1.h:187
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
VC1Context::rnd
int rnd
rounding control
Definition: vc1.h:296
Picture::hwaccel_picture_private
void * hwaccel_picture_private
Hardware accelerator private data.
Definition: mpegpicture.h:70
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:436
dxva2_internal.h
VC1Context::mv_mode
uint8_t mv_mode
Frame decoding info for all profiles.
Definition: vc1.h:231
if
if(ret)
Definition: filter_design.txt:179
VC1Context::pq
uint8_t pq
Definition: vc1.h:236
AV_CODEC_ID_WMV3
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:123
ff_vc1_dxva2_hwaccel
const AVHWAccel ff_vc1_dxva2_hwaccel
NULL
#define NULL
Definition: coverity.c:32
VC1Context::range_mapy_flag
uint8_t range_mapy_flag
Definition: vc1.h:325
ff_dxva2_decode_init
int ff_dxva2_decode_init(AVCodecContext *avctx)
Definition: dxva2.c:655
VC1Context::lumscale
uint8_t lumscale
Luma compensation parameters.
Definition: vc1.h:267
VC1Context::field_mode
int field_mode
1 for interlaced field pictures
Definition: vc1.h:349
VC1Context::panscanflag
int panscanflag
NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present.
Definition: vc1.h:201
VC1Context::range_mapuv
uint8_t range_mapuv
Definition: vc1.h:328
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
IS_MARKER
#define IS_MARKER(state)
Definition: dca_parser.c:51
ff_wmv3_d3d11va2_hwaccel
const AVHWAccel ff_wmv3_d3d11va2_hwaccel
VC1Context::resync_marker
int resync_marker
could this stream contain resync markers
Definition: vc1.h:398
FFDXVASharedContext
Definition: dxva2_internal.h:67
dxva2_picture_context
Definition: dxva2_h264.c:33
VC1Context::refdist_flag
int refdist_flag
REFDIST syntax element present in II, IP, PI or PP field picture headers.
Definition: vc1.h:202
VC1Context::mv_mode2
uint8_t mv_mode2
Secondary MV coding mode (B-frames)
Definition: vc1.h:232
dxva2_picture_context::slice_count
unsigned slice_count
Definition: dxva2_h264.c:36
MV_PMODE_MIXED_MV
@ MV_PMODE_MIXED_MV
Definition: vc1.h:82
size
int size
Definition: twinvq_data.h:10344
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
VC1Context::rangeredfrm
uint8_t rangeredfrm
Frame decoding info for S/M profiles only.
Definition: vc1.h:301
AVDXVAContext
Definition: dxva2_internal.h:58
VC1Context::chromaformat
int chromaformat
2 bits, 2=4:2:0, only defined
Definition: vc1.h:196
DECODER_BUFFER_DESC
void DECODER_BUFFER_DESC
Definition: dxva2_internal.h:56
vc1data.h
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:333
VC1Context::tfcntrflag
int tfcntrflag
TFCNTR present.
Definition: vc1.h:200
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2082
MpegEncContext::current_picture_ptr
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:174
D3D11VA_CONTEXT
#define D3D11VA_CONTEXT(ctx)
Definition: dxva2_internal.h:101
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
VC1Context::s
MpegEncContext s
Definition: vc1.h:174
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
VC1Context::extended_mv
int extended_mv
Ext MV in P/B (not in Simple)
Definition: vc1.h:221
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
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
fill_picture_parameters
static void fill_picture_parameters(AVCodecContext *avctx, AVDXVAContext *ctx, const VC1Context *v, DXVA_PictureParameters *pp)
Definition: dxva2_vc1.c:42
AVCodecContext::height
int height
Definition: avcodec.h:598
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:635
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
VC1Context::second_field
int second_field
Definition: vc1.h:351
ret
ret
Definition: filter_design.txt:187
dxva2_picture_context::slice
DXVA_SliceInfo slice[MAX_SLICES]
Definition: dxva2_mpeg2.c:36
dxva2_picture_context::bitstream
const uint8_t * bitstream
Definition: dxva2_h264.c:39
AVCodecContext
main external API structure.
Definition: avcodec.h:426
VC1Context::p_frame_skipped
int p_frame_skipped
Definition: vc1.h:382
VC1Context::bfraction_lut_index
uint8_t bfraction_lut_index
Index for BFRACTION value (see Table 40, reproduced into ff_vc1_bfraction_lut[])
Definition: vc1.h:391
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
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
VC1Context::profile
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags.
Definition: vc1.h:216
VC1Context::vstransform
int vstransform
variable-size [48]x[48] transform type + info
Definition: vc1.h:223
VC1Context::lumshift2
uint8_t lumshift2
Definition: vc1.h:336
VC1Context::bi_type
int bi_type
Definition: vc1.h:383
VC1Context::fcm
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:307
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
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
VC1Context::psf
int psf
Progressive Segmented Frame.
Definition: vc1.h:209
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
VC1Context::lumshift
uint8_t lumshift
Definition: vc1.h:268
commit_bitstream_and_slice_buffer
static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *sc)
Definition: dxva2_vc1.c:185
VC1Context::broadcast
int broadcast
TFF/RFF present.
Definition: vc1.h:198
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:453
dxva2_vc1_decode_slice
static int dxva2_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: dxva2_vc1.c:332
ff_vc1_d3d11va_hwaccel
const AVHWAccel ff_vc1_d3d11va_hwaccel
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:598
VC1Context::finterpflag
int finterpflag
INTERPFRM present.
Definition: vc1.h:226
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VC1Context::quantizer_mode
int quantizer_mode
2 bits, quantizer mode used for sequence, see QUANT_*
Definition: vc1.h:225
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_vc1.c:31
VC1Context::range_mapy
uint8_t range_mapy
Definition: vc1.h:327
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:67
VC1Context::extended_dmv
int extended_dmv
Additional extended dmv range at P/B-frame-level.
Definition: vc1.h:203
fill_slice
static void fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice, unsigned position, unsigned size)
Definition: dxva2_vc1.c:165
ff_vc1_d3d11va2_hwaccel
const AVHWAccel ff_vc1_d3d11va2_hwaccel
dxva2_picture_context::bitstream_size
unsigned bitstream_size
Definition: dxva2_h264.c:40
Generated on Tue Feb 28 2023 21:33:14 for FFmpeg by   doxygen 1.8.17