28 DXVA_PicParams_H264
pp;
38 unsigned index,
unsigned flag)
40 assert((index&0x7f) == index && (flag&0x01) == flag);
41 pic->bPicEntry = index | (flag << 7);
45 DXVA_PicParams_H264 *pp)
51 memset(pp, 0,
sizeof(*pp));
57 pp->UsedForReferenceFlags = 0;
58 pp->NonExistingFrameFlags = 0;
61 if (j < h->short_ref_count) {
65 while (!r && j < h->short_ref_count + 16)
74 pp->FieldOrderCntList[i][0] = r->
field_poc[0];
76 pp->FieldOrderCntList[i][1] = r->
field_poc[1];
80 pp->UsedForReferenceFlags |= 1 << (2*i + 0);
82 pp->UsedForReferenceFlags |= 1 << (2*i + 1);
84 pp->RefFrameList[i].bPicEntry = 0xff;
85 pp->FieldOrderCntList[i][0] = 0;
86 pp->FieldOrderCntList[i][1] = 0;
87 pp->FrameNumList[i] = 0;
91 pp->wFrameWidthInMbsMinus1 = s->
mb_width - 1;
92 pp->wFrameHeightInMbsMinus1 = s->
mb_height - 1;
118 pp->Reserved16Bits = 0;
120 pp->Reserved16Bits = 3;
121 pp->StatusReportFeedbackNumber = 1 + ctx->
report_id++;
122 pp->CurrFieldOrderCnt[0] = 0;
124 current_picture->
field_poc[0] != INT_MAX)
125 pp->CurrFieldOrderCnt[0] = current_picture->
field_poc[0];
126 pp->CurrFieldOrderCnt[1] = 0;
128 current_picture->
field_poc[1] != INT_MAX)
129 pp->CurrFieldOrderCnt[1] = current_picture->
field_poc[1];
130 pp->pic_init_qs_minus26 = h->
pps.
init_qs - 26;
133 pp->ContinuationFlag = 1;
134 pp->pic_init_qp_minus26 = h->
pps.
init_qp - 26;
135 pp->num_ref_idx_l0_active_minus1 = h->
pps.
ref_count[0] - 1;
136 pp->num_ref_idx_l1_active_minus1 = h->
pps.
ref_count[1] - 1;
137 pp->Reserved8BitsA = 0;
146 pp->entropy_coding_mode_flag = h->
pps.
cabac;
152 pp->Reserved8BitsB = 0;
153 pp->slice_group_change_rate_minus1= 0;
160 memset(qm, 0,
sizeof(*qm));
162 for (i = 0; i < 6; i++)
163 for (j = 0; j < 16; j++)
166 for (i = 0; i < 64; i++) {
171 for (i = 0; i < 6; i++)
172 for (j = 0; j < 16; j++)
175 for (i = 0; i < 64; i++) {
184 assert(ctx->
cfg->ConfigBitstreamRaw == 1 ||
185 ctx->
cfg->ConfigBitstreamRaw == 2);
186 return ctx->
cfg->ConfigBitstreamRaw == 2;
190 unsigned position,
unsigned size)
192 memset(slice, 0,
sizeof(*slice));
193 slice->BSNALunitDataLocation = position;
194 slice->SliceBytesInBuffer =
size;
195 slice->wBadSliceChopping = 0;
199 unsigned position,
unsigned size)
206 memset(slice, 0,
sizeof(*slice));
207 slice->BSNALunitDataLocation = position;
208 slice->SliceBytesInBuffer =
size;
209 slice->wBadSliceChopping = 0;
212 slice->NumMbsForSlice = 0;
216 slice->slice_type += 5;
220 slice->num_ref_idx_l0_active_minus1 = h->
ref_count[0] - 1;
222 slice->num_ref_idx_l1_active_minus1 = h->
ref_count[1] - 1;
225 slice->Reserved8Bits = 0;
227 for (list = 0; list < 2; list++) {
230 if (list < h->list_count && i < h->ref_count[list]) {
236 for (plane = 0; plane < 3; plane++) {
249 slice->Weights[list][i][plane][0] = w;
250 slice->Weights[list][i][plane][1] = o;
254 slice->RefPicList[list][i].bPicEntry = 0xff;
255 for (plane = 0; plane < 3; plane++) {
256 slice->Weights[list][i][plane][0] = 0;
257 slice->Weights[list][i][plane][1] = 0;
262 slice->slice_qs_delta = 0;
276 DXVA2_DecodeBufferDesc *bs,
277 DXVA2_DecodeBufferDesc *sc)
286 uint8_t *dxva_data, *current, *end;
294 if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->
decoder,
295 DXVA2_BitStreamDateBufferType,
296 &dxva_data, &dxva_size)))
299 end = dxva_data + dxva_size;
302 static const uint8_t start_code[] = { 0, 0, 1 };
303 static const unsigned start_code_size =
sizeof(start_code);
304 unsigned position,
size;
306 assert(offsetof(DXVA_Slice_H264_Short, BSNALunitDataLocation) ==
307 offsetof(DXVA_Slice_H264_Long, BSNALunitDataLocation));
308 assert(offsetof(DXVA_Slice_H264_Short, SliceBytesInBuffer) ==
309 offsetof(DXVA_Slice_H264_Long, SliceBytesInBuffer));
314 slice = (DXVA_Slice_H264_Short*)&ctx_pic->
slice_long[i];
316 position = slice->BSNALunitDataLocation;
317 size = slice->SliceBytesInBuffer;
318 if (start_code_size + size > end - current) {
323 slice->BSNALunitDataLocation = current - dxva_data;
324 slice->SliceBytesInBuffer = start_code_size +
size;
327 DXVA_Slice_H264_Long *
slice_long = (DXVA_Slice_H264_Long*)slice;
329 slice_long->NumMbsForSlice =
330 slice_long[1].first_mb_in_slice - slice_long[0].first_mb_in_slice;
332 slice_long->NumMbsForSlice = mb_count - slice_long->first_mb_in_slice;
335 memcpy(current, start_code, start_code_size);
336 current += start_code_size;
338 memcpy(current, &ctx_pic->
bitstream[position], size);
341 padding =
FFMIN(128 - ((current - dxva_data) & 127), end - current);
342 if (slice && padding > 0) {
343 memset(current, 0, padding);
346 slice->SliceBytesInBuffer += padding;
348 if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(ctx->
decoder,
349 DXVA2_BitStreamDateBufferType)))
354 memset(bs, 0,
sizeof(*bs));
355 bs->CompressedBufferType = DXVA2_BitStreamDateBufferType;
356 bs->DataSize = current - dxva_data;
357 bs->NumMBsInBuffer = mb_count;
366 assert((bs->DataSize & 127) == 0);
368 DXVA2_SliceControlBufferType,
369 slice_data, slice_size, mb_count);
423 ctx_pic->
pp.wBitFields &= ~(1 << 15);
437 &ctx_pic->
pp,
sizeof(ctx_pic->
pp),
438 &ctx_pic->
qm,
sizeof(ctx_pic->
qm),
443 .
name =
"h264_dxva2",
#define PICT_BOTTOM_FIELD
const uint8_t ff_zigzag_direct[64]
int ff_dxva2_common_end_frame(AVCodecContext *avctx, MpegEncContext *s, const void *pp, unsigned pp_size, const void *qm, unsigned qm_size, int(*commit_bs_si)(AVCodecContext *, DXVA2_DecodeBufferDesc *bs, DXVA2_DecodeBufferDesc *slice))
int chroma_qp_index_offset[2]
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
void * hwaccel_picture_private
hardware accelerator private data (Libav-allocated)
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, DXVA2_DecodeBufferDesc *bs, DXVA2_DecodeBufferDesc *sc)
AVHWAccel ff_h264_dxva2_hwaccel
const DXVA2_ConfigPictureDecode * cfg
DXVA2 configuration used to create the decoder.
static const uint8_t zigzag_scan[16]
unsigned surface_count
The number of surface in the surface array.
DXVA_SliceInfo slice[MAX_SLICES]
int long_ref
1->long term reference 0->short term reference
uint8_t scaling_matrix4[6][16]
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
void * hwaccel_context
Hardware accelerator context.
int luma_weight[48][2][2]
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Picture ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
int cabac
entropy_coding_mode_flag
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
static int get_bits_count(const GetBitContext *s)
int ff_h264_get_slice_type(const H264Context *h)
Reconstruct bitstream slice_type.
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
int mb_height
number of MBs horizontally & vertically
int luma_log2_weight_denom
int chroma_weight[48][2][2][2]
H.264 / AVC / MPEG4 part10 codec.
uint64_t workaround
A bit field configuring the workarounds needed for using the decoder.
int mb_aff
mb_adaptive_frame_field_flag
int poc_type
pic_order_cnt_type
int constrained_intra_pred
constrained_intra_pred_flag
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
int direct_spatial_mv_pred
int weighted_pred
weighted_pred_flag
void av_log(void *avcl, int level, const char *fmt,...)
int residual_color_transform_flag
residual_colour_transform_flag
int delta_pic_order_always_zero_flag
uint8_t scaling_matrix8[6][64]
static void fill_scaling_lists(struct dxva_context *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
int ref_frame_count
num_ref_frames
const char * name
Name of the hardware accelerated codec.
Picture * current_picture_ptr
pointer to the current picture
int ff_dxva2_commit_buffer(AVCodecContext *avctx, struct dxva_context *ctx, DXVA2_DecodeBufferDesc *dsc, unsigned type, const void *data, unsigned size, unsigned mb_count)
int init_qp
pic_init_qp_minus26 + 26
int frame_num
h264 frame_num (raw frame_num from slice header)
int direct_8x8_inference_flag
#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG
Work around for DXVA2 and old UVD/UVD+ ATI video cards.
static int is_slice_short(struct dxva_context *ctx)
static void fill_picture_parameters(struct dxva_context *ctx, const H264Context *h, DXVA_PicParams_H264 *pp)
DXVA_Slice_H264_Long slice_long[MAX_SLICES]
unsigned report_id
Private to the Libav AVHWAccel implementation.
int pic_order_present
pic_order_present_flag
int chroma_log2_weight_denom
static void fill_slice_short(DXVA_Slice_H264_Short *slice, unsigned position, unsigned size)
unsigned ff_dxva2_get_surface_index(const struct dxva_context *ctx, const Picture *picture)
H264 / AVC / MPEG4 part10 codec data table
int slice_alpha_c0_offset
main external API structure.
static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice, unsigned position, unsigned size)
static int start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
#define FF_ARRAY_ELEMS(a)
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
int field_poc[2]
h264 top/bottom POC
int transform_8x8_mode
transform_8x8_mode_flag
#define FIELD_OR_MBAFF_PICTURE
const uint8_t * bitstream
int init_qs
pic_init_qs_minus26 + 26
static int decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
int bit_depth_luma
bit_depth_luma_minus8 + 8
int pic_id
h264 pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...
int current_slice
current slice number, used to initalize slice_num of each thread/context
int slice_group_count
num_slice_groups_minus1 + 1
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
IDirectXVideoDecoder * decoder
DXVA2 decoder object.
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
DXVA_Slice_H264_Short slice_short[MAX_SLICES]
static void fill_picture_entry(DXVA_PicEntry_H264 *pic, unsigned index, unsigned flag)
This structure is used to provides the necessary configurations and data to the DXVA2 Libav HWAccel i...
int short_ref_count
number of actual short term references
static int end_frame(AVCodecContext *avctx)
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
int mb_slice_group_map_type