FFmpeg
dxva2_mpeg2.c
Go to the documentation of this file.
1 /*
2  * MPEG-2 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 "libavutil/log.h"
26 
27 #include "dxva2_internal.h"
28 #include "hwaccel_internal.h"
29 #include "mpegutils.h"
30 #include "mpegvideodec.h"
31 
32 #define MAX_SLICES 1024
33 struct dxva2_picture_context {
34  DXVA_PictureParameters pp;
35  DXVA_QmatrixData qm;
36  unsigned slice_count;
37  DXVA_SliceInfo slice[MAX_SLICES];
38 
39  const uint8_t *bitstream;
40  unsigned bitstream_size;
41 };
42 
45  DXVA_PictureParameters *pp)
46 {
47  const struct MpegEncContext *s = avctx->priv_data;
48  const Picture *current_picture = s->current_picture_ptr;
49  int is_field = s->picture_structure != PICT_FRAME;
50 
51  memset(pp, 0, sizeof(*pp));
52  pp->wDeblockedPictureIndex = 0;
53  if (s->pict_type != AV_PICTURE_TYPE_I)
54  pp->wForwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->last_picture.f, 0);
55  else
56  pp->wForwardRefPictureIndex = 0xffff;
57  if (s->pict_type == AV_PICTURE_TYPE_B)
58  pp->wBackwardRefPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, s->next_picture.f, 0);
59  else
60  pp->wBackwardRefPictureIndex = 0xffff;
61  pp->wDecodedPictureIndex = ff_dxva2_get_surface_index(avctx, ctx, current_picture->f, 1);
62  pp->wPicWidthInMBminus1 = s->mb_width - 1;
63  pp->wPicHeightInMBminus1 = (s->mb_height >> is_field) - 1;
64  pp->bMacroblockWidthMinus1 = 15;
65  pp->bMacroblockHeightMinus1 = 15;
66  pp->bBlockWidthMinus1 = 7;
67  pp->bBlockHeightMinus1 = 7;
68  pp->bBPPminus1 = 7;
69  pp->bPicStructure = s->picture_structure;
70  pp->bSecondField = is_field && !s->first_field;
71  pp->bPicIntra = s->pict_type == AV_PICTURE_TYPE_I;
72  pp->bPicBackwardPrediction = s->pict_type == AV_PICTURE_TYPE_B;
73  pp->bBidirectionalAveragingMode = 0;
74  pp->bMVprecisionAndChromaRelation= 0; /* FIXME */
75  pp->bChromaFormat = s->chroma_format;
76  pp->bPicScanFixed = 1;
77  pp->bPicScanMethod = s->alternate_scan ? 1 : 0;
78  pp->bPicReadbackRequests = 0;
79  pp->bRcontrol = 0;
80  pp->bPicSpatialResid8 = 0;
81  pp->bPicOverflowBlocks = 0;
82  pp->bPicExtrapolation = 0;
83  pp->bPicDeblocked = 0;
84  pp->bPicDeblockConfined = 0;
85  pp->bPic4MVallowed = 0;
86  pp->bPicOBMC = 0;
87  pp->bPicBinPB = 0;
88  pp->bMV_RPS = 0;
89  pp->bReservedBits = 0;
90  pp->wBitstreamFcodes = (s->mpeg_f_code[0][0] << 12) |
91  (s->mpeg_f_code[0][1] << 8) |
92  (s->mpeg_f_code[1][0] << 4) |
93  (s->mpeg_f_code[1][1] );
94  pp->wBitstreamPCEelements = (s->intra_dc_precision << 14) |
95  (s->picture_structure << 12) |
96  (s->top_field_first << 11) |
97  (s->frame_pred_frame_dct << 10) |
98  (s->concealment_motion_vectors << 9) |
99  (s->q_scale_type << 8) |
100  (s->intra_vlc_format << 7) |
101  (s->alternate_scan << 6) |
102  (s->repeat_first_field << 5) |
103  (s->chroma_420_type << 4) |
104  (s->progressive_frame << 3);
105  pp->bBitstreamConcealmentNeed = 0;
106  pp->bBitstreamConcealmentMethod = 0;
107 }
108 
111  DXVA_QmatrixData *qm)
112 {
113  const struct MpegEncContext *s = avctx->priv_data;
114  int i;
115  for (i = 0; i < 4; i++)
116  qm->bNewQmatrix[i] = 1;
117  for (i = 0; i < 64; i++) {
118  int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
119  qm->Qmatrix[0][i] = s->intra_matrix[n];
120  qm->Qmatrix[1][i] = s->inter_matrix[n];
121  qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];
122  qm->Qmatrix[3][i] = s->chroma_inter_matrix[n];
123  }
124 }
125 
127  DXVA_SliceInfo *slice,
128  unsigned position,
129  const uint8_t *buffer, unsigned size)
130 {
131  const struct MpegEncContext *s = avctx->priv_data;
132  int is_field = s->picture_structure != PICT_FRAME;
134 
135  memset(slice, 0, sizeof(*slice));
136  slice->wHorizontalPosition = s->mb_x;
137  slice->wVerticalPosition = s->mb_y >> is_field;
138  slice->dwSliceBitsInBuffer = 8 * size;
139  slice->dwSliceDataLocation = position;
140  slice->bStartCodeBitOffset = 0;
141  slice->bReservedBits = 0;
142  /* XXX We store the index of the first MB and it will be fixed later */
143  slice->wNumberMBsInSlice = (s->mb_y >> is_field) * s->mb_width + s->mb_x;
144  slice->wBadSliceChopping = 0;
145 
146  init_get_bits(&gb, &buffer[4], 8 * (size - 4));
147 
148  slice->wQuantizerScaleCode = get_bits(&gb, 5);
150 
151  slice->wMBbitOffset = 4 * 8 + get_bits_count(&gb);
152 }
156 {
157  const struct MpegEncContext *s = avctx->priv_data;
159  struct dxva2_picture_context *ctx_pic =
160  s->current_picture_ptr->hwaccel_picture_private;
161  const int is_field = s->picture_structure != PICT_FRAME;
162  const unsigned mb_count = s->mb_width * (s->mb_height >> is_field);
163  void *dxva_data_ptr;
164  uint8_t *dxva_data, *current, *end;
165  unsigned dxva_size;
166  unsigned i;
167  unsigned type;
168 
169 #if CONFIG_D3D11VA
170  if (ff_dxva2_is_d3d11(avctx)) {
171  type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
172  if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
174  type,
175  &dxva_size, &dxva_data_ptr)))
176  return -1;
177  }
178 #endif
179 #if CONFIG_DXVA2
180  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
181  type = DXVA2_BitStreamDateBufferType;
182  if (FAILED(IDirectXVideoDecoder_GetBuffer(DXVA2_CONTEXT(ctx)->decoder,
183  type,
184  &dxva_data_ptr, &dxva_size)))
185  return -1;
186  }
187 #endif
188 
189  dxva_data = dxva_data_ptr;
190  current = dxva_data;
191  end = dxva_data + dxva_size;
192 
193  for (i = 0; i < ctx_pic->slice_count; i++) {
194  DXVA_SliceInfo *slice = &ctx_pic->slice[i];
195  unsigned position = slice->dwSliceDataLocation;
196  unsigned size = slice->dwSliceBitsInBuffer / 8;
197  if (size > end - current) {
198  av_log(avctx, AV_LOG_ERROR, "Failed to build bitstream");
199  break;
200  }
201  slice->dwSliceDataLocation = current - dxva_data;
202 
203  if (i < ctx_pic->slice_count - 1)
204  slice->wNumberMBsInSlice =
205  slice[1].wNumberMBsInSlice - slice[0].wNumberMBsInSlice;
206  else
207  slice->wNumberMBsInSlice =
208  mb_count - slice[0].wNumberMBsInSlice;
209 
210  memcpy(current, &ctx_pic->bitstream[position], size);
211  current += size;
212  }
213 #if CONFIG_D3D11VA
214  if (ff_dxva2_is_d3d11(avctx))
215  if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
216  return -1;
217 #endif
218 #if CONFIG_DXVA2
219  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
220  if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type)))
221  return -1;
222 #endif
223  if (i < ctx_pic->slice_count)
224  return -1;
225 
226 #if CONFIG_D3D11VA
227  if (ff_dxva2_is_d3d11(avctx)) {
228  D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
229  memset(dsc11, 0, sizeof(*dsc11));
230  dsc11->BufferType = type;
231  dsc11->DataSize = current - dxva_data;
232  dsc11->NumMBsInBuffer = mb_count;
233 
234  type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
235  }
236 #endif
237 #if CONFIG_DXVA2
238  if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
239  DXVA2_DecodeBufferDesc *dsc2 = bs;
240  memset(dsc2, 0, sizeof(*dsc2));
241  dsc2->CompressedBufferType = type;
242  dsc2->DataSize = current - dxva_data;
243  dsc2->NumMBsInBuffer = mb_count;
244 
245  type = DXVA2_SliceControlBufferType;
246  }
247 #endif
248 
249  return ff_dxva2_commit_buffer(avctx, ctx, sc,
250  type,
251  ctx_pic->slice,
252  ctx_pic->slice_count * sizeof(*ctx_pic->slice),
253  mb_count);
254 }
255 
257  av_unused const uint8_t *buffer,
258  av_unused uint32_t size)
259 {
260  const struct MpegEncContext *s = avctx->priv_data;
262  struct dxva2_picture_context *ctx_pic =
263  s->current_picture_ptr->hwaccel_picture_private;
264 
265  if (!DXVA_CONTEXT_VALID(avctx, ctx))
266  return -1;
267  av_assert0(ctx_pic);
268 
269  ff_dxva2_mpeg2_fill_picture_parameters(avctx, ctx, &ctx_pic->pp);
271 
272  ctx_pic->slice_count = 0;
273  ctx_pic->bitstream_size = 0;
274  ctx_pic->bitstream = NULL;
275  return 0;
276 }
277 
279  const uint8_t *buffer, uint32_t size)
280 {
281  const struct MpegEncContext *s = avctx->priv_data;
282  struct dxva2_picture_context *ctx_pic =
283  s->current_picture_ptr->hwaccel_picture_private;
284  unsigned position;
285 
286  if (ctx_pic->slice_count >= MAX_SLICES) {
287  avpriv_request_sample(avctx, "%d slices in dxva2",
288  ctx_pic->slice_count);
289  return -1;
290  }
291  if (!ctx_pic->bitstream)
292  ctx_pic->bitstream = buffer;
293  ctx_pic->bitstream_size += size;
294 
295  position = buffer - ctx_pic->bitstream;
296  ff_dxva2_mpeg2_fill_slice(avctx, &ctx_pic->slice[ctx_pic->slice_count++], position,
297  buffer, size);
298  return 0;
299 }
300 
302 {
303  struct MpegEncContext *s = avctx->priv_data;
304  struct dxva2_picture_context *ctx_pic =
305  s->current_picture_ptr->hwaccel_picture_private;
306  int ret;
307 
308  if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
309  return -1;
310  ret = ff_dxva2_common_end_frame(avctx, s->current_picture_ptr->f,
311  &ctx_pic->pp, sizeof(ctx_pic->pp),
312  &ctx_pic->qm, sizeof(ctx_pic->qm),
314  if (!ret)
315  ff_mpeg_draw_horiz_band(s, 0, avctx->height);
316  return ret;
317 }
318 
319 #if CONFIG_MPEG2_DXVA2_HWACCEL
321  .p.name = "mpeg2_dxva2",
322  .p.type = AVMEDIA_TYPE_VIDEO,
323  .p.id = AV_CODEC_ID_MPEG2VIDEO,
324  .p.pix_fmt = AV_PIX_FMT_DXVA2_VLD,
325  .init = ff_dxva2_decode_init,
326  .uninit = ff_dxva2_decode_uninit,
327  .start_frame = dxva2_mpeg2_start_frame,
328  .decode_slice = dxva2_mpeg2_decode_slice,
329  .end_frame = dxva2_mpeg2_end_frame,
330  .frame_params = ff_dxva2_common_frame_params,
331  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
332  .priv_data_size = sizeof(FFDXVASharedContext),
333 };
334 #endif
335 
336 #if CONFIG_MPEG2_D3D11VA_HWACCEL
338  .p.name = "mpeg2_d3d11va",
339  .p.type = AVMEDIA_TYPE_VIDEO,
340  .p.id = AV_CODEC_ID_MPEG2VIDEO,
341  .p.pix_fmt = AV_PIX_FMT_D3D11VA_VLD,
342  .init = ff_dxva2_decode_init,
343  .uninit = ff_dxva2_decode_uninit,
344  .start_frame = dxva2_mpeg2_start_frame,
345  .decode_slice = dxva2_mpeg2_decode_slice,
346  .end_frame = dxva2_mpeg2_end_frame,
347  .frame_params = ff_dxva2_common_frame_params,
348  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
349  .priv_data_size = sizeof(FFDXVASharedContext),
350 };
351 #endif
352 
353 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
355  .p.name = "mpeg2_d3d11va2",
356  .p.type = AVMEDIA_TYPE_VIDEO,
357  .p.id = AV_CODEC_ID_MPEG2VIDEO,
358  .p.pix_fmt = AV_PIX_FMT_D3D11,
359  .init = ff_dxva2_decode_init,
360  .uninit = ff_dxva2_decode_uninit,
361  .start_frame = dxva2_mpeg2_start_frame,
362  .decode_slice = dxva2_mpeg2_decode_slice,
363  .end_frame = dxva2_mpeg2_end_frame,
364  .frame_params = ff_dxva2_common_frame_params,
365  .frame_priv_data_size = sizeof(struct dxva2_picture_context),
366  .priv_data_size = sizeof(FFDXVASharedContext),
367 };
368 #endif
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
ff_dxva2_mpeg2_fill_slice
void ff_dxva2_mpeg2_fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice, unsigned position, const uint8_t *buffer, unsigned size)
Definition: dxva2_mpeg2.c:126
MpegEncContext::gb
GetBitContext gb
Definition: mpegvideo.h:425
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
MpegEncContext::current_picture
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:169
av_unused
#define av_unused
Definition: attributes.h:131
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
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:891
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
dxva2_picture_context::pp
DXVA_PictureParameters pp
Definition: dxva2_mpeg2.c:34
dxva2_picture_context::qm
DXVA_QmatrixData qm
Definition: dxva2_mpeg2.c:35
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:85
Picture
Picture.
Definition: mpegpicture.h:46
mpegutils.h
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
ff_mpeg2_d3d11va2_hwaccel
const struct FFHWAccel ff_mpeg2_d3d11va2_hwaccel
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
decoder
static const chunk_decoder decoder[8]
Definition: dfa.c:331
FFHWAccel
Definition: hwaccel_internal.h:34
GetBitContext
Definition: get_bits.h:108
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
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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
s
#define s(width, name)
Definition: cbs_vp9.c:198
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
ctx
AVFormatContext * ctx
Definition: movenc.c:48
dxva2_mpeg2_start_frame
static int dxva2_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: dxva2_mpeg2.c:256
dxva2_internal.h
dxva2_mpeg2_decode_slice
static int dxva2_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: dxva2_mpeg2.c:278
NULL
#define NULL
Definition: coverity.c:32
ff_dxva2_decode_init
int ff_dxva2_decode_init(AVCodecContext *avctx)
Definition: dxva2.c:655
hwaccel_internal.h
dxva2_mpeg2_end_frame
static int dxva2_mpeg2_end_frame(AVCodecContext *avctx)
Definition: dxva2_mpeg2.c:301
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_mpeg2.c:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
FFDXVASharedContext
Definition: dxva2_internal.h:86
dxva2_picture_context
Definition: dxva2_h264.c:34
commit_bitstream_and_slice_buffer
static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *sc)
Definition: dxva2_mpeg2.c:153
ff_dxva2_get_surface_index
unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx, AVDXVAContext *ctx, const AVFrame *frame, int curr)
Definition: dxva2.c:770
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
ff_mpeg2_d3d11va_hwaccel
const struct FFHWAccel ff_mpeg2_d3d11va_hwaccel
size
int size
Definition: twinvq_data.h:10344
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo_dec.c:541
AVDXVAContext
Definition: dxva2_internal.h:74
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:340
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2139
D3D11VA_CONTEXT
#define D3D11VA_CONTEXT(ctx)
Definition: dxva2_internal.h:120
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
MpegEncContext::sc
ScratchpadContext sc
Definition: mpegvideo.h:192
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:802
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
ff_dxva2_common_frame_params
int ff_dxva2_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: dxva2.c:592
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
ff_mpeg2_dxva2_hwaccel
const struct FFHWAccel ff_mpeg2_dxva2_hwaccel
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
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:699
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:1056
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
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
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
ff_dxva2_mpeg2_fill_quantization_matrices
void ff_dxva2_mpeg2_fill_quantization_matrices(AVCodecContext *avctx, AVDXVAContext *ctx, DXVA_QmatrixData *qm)
Definition: dxva2_mpeg2.c:109
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
dxva2_picture_context::qm
DXVA_Qmatrix_H264 qm
Definition: dxva2_h264.c:36
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:67
dxva2_picture_context::bitstream_size
unsigned bitstream_size
Definition: dxva2_h264.c:41
ff_dxva2_mpeg2_fill_picture_parameters
void ff_dxva2_mpeg2_fill_picture_parameters(AVCodecContext *avctx, AVDXVAContext *ctx, DXVA_PictureParameters *pp)
Definition: dxva2_mpeg2.c:43