FFmpeg
vaapi_vc1.c
Go to the documentation of this file.
1 /*
2  * VC-1 HW decode acceleration through VA API
3  *
4  * Copyright (C) 2008-2009 Splitted-Desktop Systems
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/mem.h"
26 #include "hwaccel_internal.h"
27 #include "mpegvideodec.h"
28 #include "vaapi_decode.h"
29 #include "vc1.h"
30 
31 /** Translate FFmpeg MV modes to VA API */
32 static int get_VAMvModeVC1(enum MVModes mv_mode)
33 {
34  switch (mv_mode) {
35  case MV_PMODE_1MV_HPEL_BILIN: return VAMvMode1MvHalfPelBilinear;
36  case MV_PMODE_1MV: return VAMvMode1Mv;
37  case MV_PMODE_1MV_HPEL: return VAMvMode1MvHalfPel;
38  case MV_PMODE_MIXED_MV: return VAMvModeMixedMv;
39  case MV_PMODE_INTENSITY_COMP: return VAMvModeIntensityCompensation;
40  }
41  return 0;
42 }
43 
44 /** Check whether the MVTYPEMB bitplane is present */
45 static inline int vc1_has_MVTYPEMB_bitplane(const VC1Context *v)
46 {
47  if (v->mv_type_is_raw)
48  return 0;
49  return v->fcm == PROGRESSIVE &&
51  (v->mv_mode == MV_PMODE_MIXED_MV ||
54 }
55 
56 /** Check whether the SKIPMB bitplane is present */
57 static inline int vc1_has_SKIPMB_bitplane(const VC1Context *v)
58 {
59  if (v->skip_is_raw)
60  return 0;
61  return (v->fcm == PROGRESSIVE || v->fcm == ILACE_FRAME) &&
62  ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
63  (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type));
64 }
65 
66 /** Check whether the DIRECTMB bitplane is present */
67 static inline int vc1_has_DIRECTMB_bitplane(const VC1Context *v)
68 {
69  if (v->dmb_is_raw)
70  return 0;
71  return (v->fcm == PROGRESSIVE || v->fcm == ILACE_FRAME) &&
72  (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type);
73 }
74 
75 /** Check whether the ACPRED bitplane is present */
76 static inline int vc1_has_ACPRED_bitplane(const VC1Context *v)
77 {
78  if (v->acpred_is_raw)
79  return 0;
80  return v->profile == PROFILE_ADVANCED &&
81  (v->s.pict_type == AV_PICTURE_TYPE_I ||
82  (v->s.pict_type == AV_PICTURE_TYPE_B && v->bi_type));
83 }
84 
85 /** Check whether the OVERFLAGS bitplane is present */
86 static inline int vc1_has_OVERFLAGS_bitplane(const VC1Context *v)
87 {
88  if (v->overflg_is_raw)
89  return 0;
90  return v->profile == PROFILE_ADVANCED &&
91  (v->s.pict_type == AV_PICTURE_TYPE_I ||
92  (v->s.pict_type == AV_PICTURE_TYPE_B && v->bi_type)) &&
93  (v->overlap && v->pq <= 8) &&
95 }
96 
97 /** Check whether the FIELDTX bitplane is present */
98 static inline int vc1_has_FIELDTX_bitplane(const VC1Context *v)
99 {
100  if (v->fieldtx_is_raw)
101  return 0;
102  return v->fcm == ILACE_FRAME &&
103  (v->s.pict_type == AV_PICTURE_TYPE_I ||
104  (v->s.pict_type == AV_PICTURE_TYPE_B && v->bi_type));
105 }
106 
107 /** Check whether the FORWARDMB bitplane is present */
108 static inline int vc1_has_FORWARDMB_bitplane(const VC1Context *v)
109 {
110  if (v->fmb_is_raw)
111  return 0;
112  return v->fcm == ILACE_FIELD &&
113  (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type);
114 }
115 
116 /** Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35) */
117 static int vc1_get_PTYPE(const VC1Context *v)
118 {
119  const MpegEncContext *s = &v->s;
120  switch (s->pict_type) {
121  case AV_PICTURE_TYPE_I: return 0;
122  case AV_PICTURE_TYPE_P: return v->p_frame_skipped ? 4 : 1;
123  case AV_PICTURE_TYPE_B: return v->bi_type ? 3 : 2;
124  }
125  return 0;
126 }
127 
128 /** Reconstruct bitstream FPTYPE (9.1.1.42, index into Table-105) */
129 static int vc1_get_FPTYPE(const VC1Context *v)
130 {
131  const MpegEncContext *s = &v->s;
132  switch (s->pict_type) {
133  case AV_PICTURE_TYPE_I: return 0;
134  case AV_PICTURE_TYPE_P: return 3;
135  case AV_PICTURE_TYPE_B: return v->bi_type ? 7 : 4;
136  }
137  return 0;
138 }
139 
140 /** Reconstruct bitstream MVMODE (7.1.1.32) */
141 static inline VAMvModeVC1 vc1_get_MVMODE(const VC1Context *v)
142 {
143  if ((v->fcm == PROGRESSIVE || v->fcm == ILACE_FIELD) &&
144  ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) ||
145  (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type)))
146  return get_VAMvModeVC1(v->mv_mode);
147  return 0;
148 }
149 
150 /** Reconstruct bitstream MVMODE2 (7.1.1.33) */
151 static inline VAMvModeVC1 vc1_get_MVMODE2(const VC1Context *v)
152 {
153  if ((v->fcm == PROGRESSIVE || v->fcm == ILACE_FIELD) &&
154  (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&
156  return get_VAMvModeVC1(v->mv_mode2);
157  return 0;
158 }
159 
160 av_unused static inline int vc1_get_INTCOMPFIELD(const VC1Context *v)
161 {
162  if ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&
163  v->fcm == ILACE_FIELD &&
165  switch (v->intcompfield) {
166  case 1: return 1;
167  case 2: return 2;
168  case 3: return 0;
169  }
170  return 0;
171 }
172 
173 static inline int vc1_get_LUMSCALE(const VC1Context *v)
174 {
175  if (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) {
176  if ((v->fcm == PROGRESSIVE && v->mv_mode == MV_PMODE_INTENSITY_COMP) ||
177  (v->fcm == ILACE_FRAME && v->intcomp))
178  return v->lumscale;
179  else if (v->fcm == ILACE_FIELD && v->mv_mode == MV_PMODE_INTENSITY_COMP)
180  switch (v->intcompfield) {
181  case 1: return v->lumscale;
182  case 2: return v->lumscale2;
183  case 3: return v->lumscale;
184  }
185  }
186  return 0;
187 }
188 
189 static inline int vc1_get_LUMSHIFT(const VC1Context *v)
190 {
191  if (v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) {
192  if ((v->fcm == PROGRESSIVE && v->mv_mode == MV_PMODE_INTENSITY_COMP) ||
193  (v->fcm == ILACE_FRAME && v->intcomp))
194  return v->lumshift;
195  else if (v->fcm == ILACE_FIELD && v->mv_mode == MV_PMODE_INTENSITY_COMP)
196  switch (v->intcompfield) {
197  case 1: return v->lumshift;
198  case 2: return v->lumshift2;
199  case 3: return v->lumshift;
200  }
201  }
202  return 0;
203 }
204 
205 av_unused static inline int vc1_get_LUMSCALE2(const VC1Context *v)
206 {
207  if ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&
208  v->fcm == ILACE_FIELD &&
210  v->intcompfield == 3)
211  return v->lumscale2;
212  return 0;
213 }
214 
215 av_unused static inline int vc1_get_LUMSHIFT2(const VC1Context *v)
216 {
217  if ((v->s.pict_type == AV_PICTURE_TYPE_P && !v->p_frame_skipped) &&
218  v->fcm == ILACE_FIELD &&
220  v->intcompfield == 3)
221  return v->lumshift2;
222  return 0;
223 }
224 
225 /** Reconstruct bitstream TTFRM (7.1.1.41, Table-53) */
226 static inline int vc1_get_TTFRM(const VC1Context *v)
227 {
228  switch (v->ttfrm) {
229  case TT_8X8: return 0;
230  case TT_8X4: return 1;
231  case TT_4X8: return 2;
232  case TT_4X4: return 3;
233  }
234  return 0;
235 }
236 
237 /** Pack FFmpeg bitplanes into a VABitPlaneBuffer element */
238 static inline void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *ff_bp[3], int x, int y, int stride)
239 {
240  const int bitplane_index = n / 2;
241  const int ff_bp_index = y * stride + x;
242  uint8_t v = 0;
243  if (ff_bp[0])
244  v = ff_bp[0][ff_bp_index];
245  if (ff_bp[1])
246  v |= ff_bp[1][ff_bp_index] << 1;
247  if (ff_bp[2])
248  v |= ff_bp[2][ff_bp_index] << 2;
249  bitplane[bitplane_index] = (bitplane[bitplane_index] << 4) | v;
250 }
251 
252 static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
253 {
254  const VC1Context *v = avctx->priv_data;
255  const MpegEncContext *s = &v->s;
256  VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private;
257  VAPictureParameterBufferVC1 pic_param;
258  int err;
259 
260  pic->output_surface = ff_vaapi_get_surface_id(s->cur_pic.ptr->f);
261 
262  pic_param = (VAPictureParameterBufferVC1) {
263  .forward_reference_picture = VA_INVALID_ID,
264  .backward_reference_picture = VA_INVALID_ID,
265  .inloop_decoded_picture = VA_INVALID_ID,
266  .sequence_fields.bits = {
267  .pulldown = v->broadcast,
268  .interlace = v->interlace,
269  .tfcntrflag = v->tfcntrflag,
270  .finterpflag = v->finterpflag,
271  .psf = v->psf,
272  .multires = v->multires,
273  .overlap = v->overlap,
274  .syncmarker = v->resync_marker,
275  .rangered = v->rangered,
276  .max_b_frames = s->avctx->max_b_frames,
277  .profile = v->profile,
278  },
279  .coded_width = s->avctx->coded_width,
280  .coded_height = s->avctx->coded_height,
281  .entrypoint_fields.bits = {
282  .broken_link = v->broken_link,
283  .closed_entry = v->closed_entry,
284  .panscan_flag = v->panscanflag,
285  .loopfilter = s->loop_filter,
286  },
287  .conditional_overlap_flag = v->condover,
288  .fast_uvmc_flag = v->fastuvmc,
289  .range_mapping_fields.bits = {
290  .luma_flag = v->range_mapy_flag,
291  .luma = v->range_mapy,
292  .chroma_flag = v->range_mapuv_flag,
293  .chroma = v->range_mapuv,
294  },
295  .b_picture_fraction = v->bfraction_lut_index,
296  .cbp_table = (v->fcm == PROGRESSIVE ? v->cbptab : v->icbptab),
297  .mb_mode_table = v->mbmodetab,
298  .range_reduction_frame = v->rangeredfrm,
299  .rounding_control = v->rnd,
300  .post_processing = v->postproc,
301  .picture_resolution_index = v->respic,
302  .picture_fields.bits = {
303  .picture_type = (v->fcm == ILACE_FIELD ? vc1_get_FPTYPE(v) : vc1_get_PTYPE(v)),
304  .frame_coding_mode = v->fcm,
305  .top_field_first = v->tff,
306  .is_first_field = !v->second_field,
307  .intensity_compensation = v->intcomp,
308  },
309  .luma_scale = vc1_get_LUMSCALE(v),
310  .luma_shift = vc1_get_LUMSHIFT(v),
311 #if VA_CHECK_VERSION(1, 1, 0)
312  .luma_scale2 = vc1_get_LUMSCALE2(v),
313  .luma_shift2 = vc1_get_LUMSHIFT2(v),
314  .intensity_compensation_field = vc1_get_INTCOMPFIELD(v),
315 #endif
316  .raw_coding.flags = {
317  .mv_type_mb = v->mv_type_is_raw,
318  .direct_mb = v->dmb_is_raw,
319  .skip_mb = v->skip_is_raw,
320  .field_tx = v->fieldtx_is_raw,
321  .forward_mb = v->fmb_is_raw,
322  .ac_pred = v->acpred_is_raw,
323  .overflags = v->overflg_is_raw,
324  },
325  .bitplane_present.flags = {
326  .bp_mv_type_mb = vc1_has_MVTYPEMB_bitplane(v),
327  .bp_direct_mb = vc1_has_DIRECTMB_bitplane(v),
328  .bp_skip_mb = vc1_has_SKIPMB_bitplane(v),
329  .bp_field_tx = vc1_has_FIELDTX_bitplane(v),
330  .bp_forward_mb = vc1_has_FORWARDMB_bitplane(v),
331  .bp_ac_pred = vc1_has_ACPRED_bitplane(v),
332  .bp_overflags = vc1_has_OVERFLAGS_bitplane(v),
333  },
334  .reference_fields.bits = {
335  .reference_distance_flag = v->refdist_flag,
336  .reference_distance = v->refdist,
337  .num_reference_pictures = v->numref,
338  .reference_field_pic_indicator = v->reffield,
339  },
340  .mv_fields.bits = {
341  .mv_mode = vc1_get_MVMODE(v),
342  .mv_mode2 = vc1_get_MVMODE2(v),
343  .mv_table = (v->fcm == PROGRESSIVE ? s->mv_table_index : v->imvtab),
344  .two_mv_block_pattern_table = v->twomvbptab,
345  .four_mv_switch = v->fourmvswitch,
346  .four_mv_block_pattern_table = v->fourmvbptab,
347  .extended_mv_flag = v->extended_mv,
348  .extended_mv_range = v->mvrange,
349  .extended_dmv_flag = v->extended_dmv,
350  .extended_dmv_range = v->dmvrange,
351  },
352  .pic_quantizer_fields.bits = {
353  .dquant = v->dquant,
354  .quantizer = v->quantizer_mode,
355  .half_qp = v->halfpq,
356  .pic_quantizer_scale = v->pq,
357  .pic_quantizer_type = v->pquantizer,
358  .dq_frame = v->dquantfrm,
359  .dq_profile = v->dqprofile,
360  .dq_sb_edge = v->dqprofile == DQPROFILE_SINGLE_EDGE ? v->dqsbedge : 0,
361  .dq_db_edge = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0,
362  .dq_binary_level = v->dqbilevel,
363  .alt_pic_quantizer = v->altpq,
364  },
365  .transform_fields.bits = {
366  .variable_sized_transform_flag = v->vstransform,
367  .mb_level_transform_type_flag = v->ttmbf,
368  .frame_level_transform_type = vc1_get_TTFRM(v),
369  .transform_ac_codingset_idx1 = v->c_ac_table_index,
370  .transform_ac_codingset_idx2 = v->y_ac_table_index,
371  .intra_transform_dc_table = v->s.dc_table_index,
372  },
373  };
374 
375  switch (s->pict_type) {
376  case AV_PICTURE_TYPE_B:
377  if (s->next_pic.ptr)
378  pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_pic.ptr->f);
379  // fall-through
380  case AV_PICTURE_TYPE_P:
381  if (s->last_pic.ptr)
382  pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_pic.ptr->f);
383  break;
384  }
385 
386  err = ff_vaapi_decode_make_param_buffer(avctx, pic,
387  VAPictureParameterBufferType,
388  &pic_param, sizeof(pic_param));
389  if (err)
390  goto fail;
391 
392  if (pic_param.bitplane_present.value & 0x7f) {
393  uint8_t *bitplane;
394  const uint8_t *ff_bp[3];
395  int x, y, n;
396  size_t size = (s->mb_width * s->mb_height + 1) / 2;
397 
398  bitplane = av_mallocz(size);
399  if (!bitplane) {
400  err = AVERROR(ENOMEM);
401  goto fail;
402  }
403 
404  switch (s->pict_type) {
405  case AV_PICTURE_TYPE_P:
406  ff_bp[0] = pic_param.bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL;
407  ff_bp[1] = pic_param.bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL;
408  ff_bp[2] = pic_param.bitplane_present.flags.bp_mv_type_mb ? v->mv_type_mb_plane : NULL;
409  break;
410  case AV_PICTURE_TYPE_B:
411  if (!v->bi_type) {
412  ff_bp[0] = pic_param.bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL;
413  ff_bp[1] = pic_param.bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL;
414  ff_bp[2] = pic_param.bitplane_present.flags.bp_forward_mb ? v->forward_mb_plane : NULL;
415  break;
416  }
417  /* fall-through (BI-type) */
418  case AV_PICTURE_TYPE_I:
419  ff_bp[0] = pic_param.bitplane_present.flags.bp_field_tx ? v->fieldtx_plane : NULL;
420  ff_bp[1] = pic_param.bitplane_present.flags.bp_ac_pred ? v->acpred_plane : NULL;
421  ff_bp[2] = pic_param.bitplane_present.flags.bp_overflags ? v->over_flags_plane : NULL;
422  break;
423  default:
424  ff_bp[0] = NULL;
425  ff_bp[1] = NULL;
426  ff_bp[2] = NULL;
427  break;
428  }
429 
430  n = 0;
431  for (y = 0; y < s->mb_height; y++)
432  for (x = 0; x < s->mb_width; x++, n++)
433  vc1_pack_bitplanes(bitplane, n, ff_bp, x, y, s->mb_stride);
434  if (n & 1) /* move last nibble to the high order */
435  bitplane[n/2] <<= 4;
436 
437  err = ff_vaapi_decode_make_param_buffer(avctx, pic,
438  VABitPlaneBufferType,
439  bitplane, size);
440  av_free(bitplane);
441  if (err)
442  goto fail;
443  }
444  return 0;
445 
446 fail:
447  ff_vaapi_decode_cancel(avctx, pic);
448  return err;
449 }
450 
452 {
453  VC1Context *v = avctx->priv_data;
454  MpegEncContext *s = &v->s;
455  VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private;
456  int ret;
457 
458  ret = ff_vaapi_decode_issue(avctx, pic);
459  if (ret < 0)
460  goto fail;
461 
462 fail:
463  return ret;
464 }
465 
466 static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
467 {
468  const VC1Context *v = avctx->priv_data;
469  const MpegEncContext *s = &v->s;
470  VAAPIDecodePicture *pic = s->cur_pic.ptr->hwaccel_picture_private;
471  VASliceParameterBufferVC1 slice_param;
472  int mb_height;
473  int err;
474 
475  /* Current bit buffer is beyond any marker for VC-1, so skip it */
476  if (avctx->codec_id == AV_CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {
477  buffer += 4;
478  size -= 4;
479  }
480 
481  if (v->fcm == ILACE_FIELD)
482  mb_height = avctx->coded_height + 31 >> 5;
483  else
484  mb_height = avctx->coded_height + 15 >> 4;
485 
486  slice_param = (VASliceParameterBufferVC1) {
487  .slice_data_size = size,
488  .slice_data_offset = 0,
489  .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
490  .macroblock_offset = get_bits_count(&s->gb),
491  .slice_vertical_position = s->mb_y % mb_height,
492  };
493 
494  err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
495  &slice_param, 1, sizeof(slice_param),
496  buffer, size);
497  if (err < 0) {
498  ff_vaapi_decode_cancel(avctx, pic);
499  return err;
500  }
501 
502  return 0;
503 }
504 
505 #if CONFIG_WMV3_VAAPI_HWACCEL
507  .p.name = "wmv3_vaapi",
508  .p.type = AVMEDIA_TYPE_VIDEO,
509  .p.id = AV_CODEC_ID_WMV3,
510  .p.pix_fmt = AV_PIX_FMT_VAAPI,
511  .start_frame = &vaapi_vc1_start_frame,
512  .end_frame = &vaapi_vc1_end_frame,
513  .decode_slice = &vaapi_vc1_decode_slice,
514  .frame_priv_data_size = sizeof(VAAPIDecodePicture),
517  .frame_params = &ff_vaapi_common_frame_params,
518  .priv_data_size = sizeof(VAAPIDecodeContext),
519  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
520 };
521 #endif
522 
524  .p.name = "vc1_vaapi",
525  .p.type = AVMEDIA_TYPE_VIDEO,
526  .p.id = AV_CODEC_ID_VC1,
527  .p.pix_fmt = AV_PIX_FMT_VAAPI,
528  .start_frame = &vaapi_vc1_start_frame,
529  .end_frame = &vaapi_vc1_end_frame,
530  .decode_slice = &vaapi_vc1_decode_slice,
531  .frame_priv_data_size = sizeof(VAAPIDecodePicture),
534  .frame_params = &ff_vaapi_common_frame_params,
535  .priv_data_size = sizeof(VAAPIDecodeContext),
536  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
537 };
VC1Context::lumscale2
uint8_t lumscale2
for interlaced field P picture
Definition: vc1.h:336
VC1Context::mbmodetab
int mbmodetab
Definition: vc1.h:368
VC1Context
The VC1 Context.
Definition: vc1.h:173
AVERROR
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 all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
PROGRESSIVE
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition: vc1.h:149
ff_vaapi_get_surface_id
static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
Definition: vaapi_decode.h:30
VC1Context::condover
uint8_t condover
Definition: vc1.h:325
DQPROFILE_DOUBLE_EDGES
@ DQPROFILE_DOUBLE_EDGES
Definition: vc1.h:49
VC1Context::intcomp
int intcomp
Definition: vc1.h:335
VC1Context::overlap
int overlap
overlapped transforms in use
Definition: vc1.h:224
VC1Context::dqprofile
uint8_t dqprofile
Definition: vc1.h:244
VC1Context::interlace
int interlace
Progressive/interlaced (RPTFTM syntax element)
Definition: vc1.h:199
VAAPIDecodeContext
Definition: vaapi_decode.h:47
VC1Context::altpq
uint8_t altpq
Current/alternate frame quantizer scale.
Definition: vc1.h:236
vc1.h
ILACE_FRAME
@ ILACE_FRAME
in the bitstream is reported as 10b
Definition: vc1.h:150
vaapi_decode.h
vc1_has_MVTYPEMB_bitplane
static int vc1_has_MVTYPEMB_bitplane(const VC1Context *v)
Check whether the MVTYPEMB bitplane is present.
Definition: vaapi_vc1.c:45
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
VAAPIDecodePicture
Definition: vaapi_decode.h:35
MV_PMODE_1MV_HPEL_BILIN
@ MV_PMODE_1MV_HPEL_BILIN
Definition: vc1.h:79
VC1Context::reffield
int reffield
if numref = 0 (1 reference) then reffield decides which
Definition: vc1.h:356
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
VC1Context::imvtab
int imvtab
Definition: vc1.h:370
VC1Context::dmvrange
uint8_t dmvrange
Frame decoding info for interlaced picture.
Definition: vc1.h:333
VC1Context::closed_entry
uint8_t closed_entry
Closed entry point flag (CLOSED_ENTRY syntax element)
Definition: vc1.h:394
VC1Context::twomvbptab
int twomvbptab
Definition: vc1.h:371
VC1Context::fieldtx_is_raw
int fieldtx_is_raw
Definition: vc1.h:345
ff_vaapi_decode_make_param_buffer
int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, int type, const void *data, size_t size)
Definition: vaapi_decode.c:34
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:206
FFHWAccel
Definition: hwaccel_internal.h:34
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
fail
#define fail()
Definition: checkasm.h:193
vaapi_vc1_start_frame
static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vaapi_vc1.c:252
vc1_get_PTYPE
static int vc1_get_PTYPE(const VC1Context *v)
Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35)
Definition: vaapi_vc1.c:117
vc1_get_MVMODE
static VAMvModeVC1 vc1_get_MVMODE(const VC1Context *v)
Reconstruct bitstream MVMODE (7.1.1.32)
Definition: vaapi_vc1.c:141
VC1Context::numref
int numref
number of past field pictures used as reference
Definition: vc1.h:354
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
vc1_has_FIELDTX_bitplane
static int vc1_has_FIELDTX_bitplane(const VC1Context *v)
Check whether the FIELDTX bitplane is present.
Definition: vaapi_vc1.c:98
VC1Context::c_ac_table_index
int c_ac_table_index
AC coding set indexes.
Definition: vc1.h:252
VC1Context::dquant
int dquant
How qscale varies with MBs, 2 bits (not in Simple)
Definition: vc1.h:222
VAAPIDecodePicture::output_surface
VASurfaceID output_surface
Definition: vaapi_decode.h:36
VC1Context::refdist
int refdist
distance of the current picture from reference
Definition: vc1.h:353
mpegvideodec.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_vaapi_decode_init
int ff_vaapi_decode_init(AVCodecContext *avctx)
Definition: vaapi_decode.c:692
VC1Context::range_mapuv_flag
uint8_t range_mapuv_flag
Definition: vc1.h:327
ff_vaapi_common_frame_params
int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: vaapi_decode.c:668
DQPROFILE_SINGLE_EDGE
@ DQPROFILE_SINGLE_EDGE
Definition: vc1.h:50
TT_8X4
@ TT_8X4
Definition: vc1.h:115
vc1_has_SKIPMB_bitplane
static int vc1_has_SKIPMB_bitplane(const VC1Context *v)
Check whether the SKIPMB bitplane is present.
Definition: vaapi_vc1.c:57
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
ff_vaapi_decode_uninit
int ff_vaapi_decode_uninit(AVCodecContext *avctx)
Definition: vaapi_decode.c:738
VC1Context::rnd
int rnd
rounding control
Definition: vc1.h:297
MVModes
MVModes
MV modes for P-frames.
Definition: vc1.h:78
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
vaapi_vc1_end_frame
static int vaapi_vc1_end_frame(AVCodecContext *avctx)
Definition: vaapi_vc1.c:451
ff_vaapi_decode_issue
int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:166
VC1Context::mv_mode
uint8_t mv_mode
Frame decoding info for all profiles.
Definition: vc1.h:231
VC1Context::dqsbedge
uint8_t dqsbedge
Definition: vc1.h:245
VC1Context::pq
uint8_t pq
Definition: vc1.h:236
AV_CODEC_ID_WMV3
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:123
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
VC1Context::skip_is_raw
int skip_is_raw
skip mb plane is not coded
Definition: vc1.h:290
NULL
#define NULL
Definition: coverity.c:32
VC1Context::range_mapy_flag
uint8_t range_mapy_flag
Definition: vc1.h:326
hwaccel_internal.h
VC1Context::lumscale
uint8_t lumscale
Luma compensation parameters.
Definition: vc1.h:267
VC1Context::panscanflag
int panscanflag
NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present.
Definition: vc1.h:201
VC1Context::mvrange
uint8_t mvrange
Ranges:
Definition: vc1.h:280
VC1Context::range_mapuv
uint8_t range_mapuv
Definition: vc1.h:329
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
VC1Context::fmb_is_raw
int fmb_is_raw
forward mb plane is raw
Definition: vc1.h:289
IS_MARKER
#define IS_MARKER(state)
Definition: dca_parser.c:51
vc1_pack_bitplanes
static void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *ff_bp[3], int x, int y, int stride)
Pack FFmpeg bitplanes into a VABitPlaneBuffer element.
Definition: vaapi_vc1.c:238
VC1Context::resync_marker
int resync_marker
could this stream contain resync markers
Definition: vc1.h:399
get_VAMvModeVC1
static int get_VAMvModeVC1(enum MVModes mv_mode)
Translate FFmpeg MV modes to VA API.
Definition: vaapi_vc1.c:32
VC1Context::cbptab
int cbptab
Definition: vc1.h:298
VC1Context::halfpq
uint8_t halfpq
Uniform quant over image and qp+.5.
Definition: vc1.h:271
VC1Context::ttmbf
uint8_t ttmbf
Transform type flag.
Definition: vc1.h:256
VC1Context::refdist_flag
int refdist_flag
REFDIST syntax element present in II, IP, PI or PP field picture headers.
Definition: vc1.h:202
vc1_has_DIRECTMB_bitplane
static int vc1_has_DIRECTMB_bitplane(const VC1Context *v)
Check whether the DIRECTMB bitplane is present.
Definition: vaapi_vc1.c:67
VC1Context::intcompfield
int intcompfield
which of the two fields to be intensity compensated
Definition: vc1.h:358
VC1Context::mv_mode2
uint8_t mv_mode2
Secondary MV coding mode (B-frames)
Definition: vc1.h:232
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
VC1Context::ttfrm
int ttfrm
Transform type info present at frame level.
Definition: vc1.h:255
MV_PMODE_MIXED_MV
@ MV_PMODE_MIXED_MV
Definition: vc1.h:82
size
int size
Definition: twinvq_data.h:10344
vc1_get_LUMSHIFT2
static av_unused int vc1_get_LUMSHIFT2(const VC1Context *v)
Definition: vaapi_vc1.c:215
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
vc1_get_INTCOMPFIELD
static av_unused int vc1_get_INTCOMPFIELD(const VC1Context *v)
Definition: vaapi_vc1.c:160
VC1Context::fourmvswitch
int fourmvswitch
Definition: vc1.h:334
VC1Context::rangeredfrm
uint8_t rangeredfrm
Frame decoding info for S/M profiles only.
Definition: vc1.h:302
ff_vaapi_decode_cancel
int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:247
VC1Context::respic
uint8_t respic
Frame-level flag for resized images.
Definition: vc1.h:272
MV_PMODE_1MV_HPEL
@ MV_PMODE_1MV_HPEL
Definition: vc1.h:81
vc1_get_FPTYPE
static int vc1_get_FPTYPE(const VC1Context *v)
Reconstruct bitstream FPTYPE (9.1.1.42, index into Table-105)
Definition: vaapi_vc1.c:129
VC1Context::broken_link
uint8_t broken_link
Broken link flag (BROKEN_LINK syntax element)
Definition: vc1.h:393
VC1Context::tfcntrflag
int tfcntrflag
TFCNTR present.
Definition: vc1.h:200
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2105
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
ff_vc1_vaapi_hwaccel
const FFHWAccel ff_vc1_vaapi_hwaccel
Definition: vaapi_vc1.c:523
vc1_get_TTFRM
static int vc1_get_TTFRM(const VC1Context *v)
Reconstruct bitstream TTFRM (7.1.1.41, Table-53)
Definition: vaapi_vc1.c:226
vc1_get_LUMSCALE2
static av_unused int vc1_get_LUMSCALE2(const VC1Context *v)
Definition: vaapi_vc1.c:205
VC1Context::s
MpegEncContext s
Definition: vc1.h:174
VC1Context::extended_mv
int extended_mv
Ext MV in P/B (not in Simple)
Definition: vc1.h:221
vc1_get_LUMSCALE
static int vc1_get_LUMSCALE(const VC1Context *v)
Definition: vaapi_vc1.c:173
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
MpegEncContext::dc_table_index
int dc_table_index
Definition: mpegvideo.h:414
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
stride
#define stride
Definition: h264pred_template.c:537
VC1Context::second_field
int second_field
Definition: vc1.h:352
ret
ret
Definition: filter_design.txt:187
VC1Context::y_ac_table_index
int y_ac_table_index
Luma index from AC2FRM element.
Definition: vc1.h:253
VC1Context::overflg_is_raw
int overflg_is_raw
Definition: vc1.h:324
VC1Context::pquantizer
uint8_t pquantizer
Uniform (over sequence) quantizer in use.
Definition: vc1.h:281
AVCodecContext
main external API structure.
Definition: avcodec.h:451
VC1Context::p_frame_skipped
int p_frame_skipped
Definition: vc1.h:383
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:392
vc1_has_ACPRED_bitplane
static int vc1_has_ACPRED_bitplane(const VC1Context *v)
Check whether the ACPRED bitplane is present.
Definition: vaapi_vc1.c:76
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
VC1Context::tff
uint8_t tff
Definition: vc1.h:311
ff_vaapi_decode_make_slice_buffer
int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, const void *params_data, int nb_params, size_t params_size, const void *slice_data, size_t slice_size)
Definition: vaapi_decode.c:75
vc1_get_LUMSHIFT
static int vc1_get_LUMSHIFT(const VC1Context *v)
Definition: vaapi_vc1.c:189
VC1Context::fourmvbptab
int fourmvbptab
Definition: vc1.h:372
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:337
VC1Context::bi_type
int bi_type
Definition: vc1.h:384
VC1Context::dqbilevel
uint8_t dqbilevel
Definition: vc1.h:246
TT_4X8
@ TT_4X8
Definition: vc1.h:118
VC1Context::fcm
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:308
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
VC1Context::mv_type_is_raw
int mv_type_is_raw
mv type mb plane is not coded
Definition: vc1.h:287
VC1Context::psf
int psf
Progressive Segmented Frame.
Definition: vc1.h:209
mem.h
VC1Context::lumshift
uint8_t lumshift
Definition: vc1.h:268
VC1Context::broadcast
int broadcast
TFF/RFF present.
Definition: vc1.h:198
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
VC1Context::dmb_is_raw
int dmb_is_raw
direct mb plane is raw
Definition: vc1.h:288
vc1_has_OVERFLAGS_bitplane
static int vc1_has_OVERFLAGS_bitplane(const VC1Context *v)
Check whether the OVERFLAGS bitplane is present.
Definition: vaapi_vc1.c:86
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
TT_8X8
@ TT_8X8
Definition: vc1.h:112
VC1Context::acpred_is_raw
int acpred_is_raw
Definition: vc1.h:322
VC1Context::finterpflag
int finterpflag
INTERPFRM present.
Definition: vc1.h:226
vc1_get_MVMODE2
static VAMvModeVC1 vc1_get_MVMODE2(const VC1Context *v)
Reconstruct bitstream MVMODE2 (7.1.1.33)
Definition: vaapi_vc1.c:151
VC1Context::icbptab
int icbptab
Definition: vc1.h:369
VC1Context::dquantfrm
uint8_t dquantfrm
pquant parameters
Definition: vc1.h:243
vc1_has_FORWARDMB_bitplane
static int vc1_has_FORWARDMB_bitplane(const VC1Context *v)
Check whether the FORWARDMB bitplane is present.
Definition: vaapi_vc1.c:108
vaapi_vc1_decode_slice
static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: vaapi_vc1.c:466
VC1Context::quantizer_mode
int quantizer_mode
2 bits, quantizer mode used for sequence, see QUANT_*
Definition: vc1.h:225
CONDOVER_SELECT
@ CONDOVER_SELECT
Definition: vc1.h:139
MV_PMODE_1MV
@ MV_PMODE_1MV
Definition: vc1.h:80
VC1Context::postproc
uint8_t postproc
Definition: vc1.h:317
TT_4X4
@ TT_4X4
Definition: vc1.h:119
VC1Context::range_mapy
uint8_t range_mapy
Definition: vc1.h:328
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
VC1Context::extended_dmv
int extended_dmv
Additional extended dmv range at P/B-frame-level.
Definition: vc1.h:203
ff_wmv3_vaapi_hwaccel
const struct FFHWAccel ff_wmv3_vaapi_hwaccel