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