blob: 59fa5e376921e45132a7cd5b2b7c6082350bfce1
1 | /* |
2 | * DXVA2 H.264 HW acceleration. |
3 | * |
4 | * copyright (c) 2009 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 "libavutil/avassert.h" |
24 | |
25 | #include "h264dec.h" |
26 | #include "h264data.h" |
27 | #include "h264_ps.h" |
28 | #include "mpegutils.h" |
29 | |
30 | // The headers above may include w32threads.h, which uses the original |
31 | // _WIN32_WINNT define, while dxva2_internal.h redefines it to target a |
32 | // potentially newer version. |
33 | #include "dxva2_internal.h" |
34 | |
35 | struct dxva2_picture_context { |
36 | DXVA_PicParams_H264 pp; |
37 | DXVA_Qmatrix_H264 qm; |
38 | unsigned slice_count; |
39 | DXVA_Slice_H264_Short slice_short[MAX_SLICES]; |
40 | DXVA_Slice_H264_Long slice_long[MAX_SLICES]; |
41 | const uint8_t *bitstream; |
42 | unsigned bitstream_size; |
43 | }; |
44 | |
45 | static void fill_picture_entry(DXVA_PicEntry_H264 *pic, |
46 | unsigned index, unsigned flag) |
47 | { |
48 | assert((index&0x7f) == index && (flag&0x01) == flag); |
49 | pic->bPicEntry = index | (flag << 7); |
50 | } |
51 | |
52 | static void fill_picture_parameters(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, |
53 | DXVA_PicParams_H264 *pp) |
54 | { |
55 | const H264Picture *current_picture = h->cur_pic_ptr; |
56 | const SPS *sps = h->ps.sps; |
57 | const PPS *pps = h->ps.pps; |
58 | int i, j; |
59 | |
60 | memset(pp, 0, sizeof(*pp)); |
61 | /* Configure current picture */ |
62 | fill_picture_entry(&pp->CurrPic, |
63 | ff_dxva2_get_surface_index(avctx, ctx, current_picture->f), |
64 | h->picture_structure == PICT_BOTTOM_FIELD); |
65 | /* Configure the set of references */ |
66 | pp->UsedForReferenceFlags = 0; |
67 | pp->NonExistingFrameFlags = 0; |
68 | for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) { |
69 | const H264Picture *r; |
70 | if (j < h->short_ref_count) { |
71 | r = h->short_ref[j++]; |
72 | } else { |
73 | r = NULL; |
74 | while (!r && j < h->short_ref_count + 16) |
75 | r = h->long_ref[j++ - h->short_ref_count]; |
76 | } |
77 | if (r) { |
78 | fill_picture_entry(&pp->RefFrameList[i], |
79 | ff_dxva2_get_surface_index(avctx, ctx, r->f), |
80 | r->long_ref != 0); |
81 | |
82 | if ((r->reference & PICT_TOP_FIELD) && r->field_poc[0] != INT_MAX) |
83 | pp->FieldOrderCntList[i][0] = r->field_poc[0]; |
84 | if ((r->reference & PICT_BOTTOM_FIELD) && r->field_poc[1] != INT_MAX) |
85 | pp->FieldOrderCntList[i][1] = r->field_poc[1]; |
86 | |
87 | pp->FrameNumList[i] = r->long_ref ? r->pic_id : r->frame_num; |
88 | if (r->reference & PICT_TOP_FIELD) |
89 | pp->UsedForReferenceFlags |= 1 << (2*i + 0); |
90 | if (r->reference & PICT_BOTTOM_FIELD) |
91 | pp->UsedForReferenceFlags |= 1 << (2*i + 1); |
92 | } else { |
93 | pp->RefFrameList[i].bPicEntry = 0xff; |
94 | pp->FieldOrderCntList[i][0] = 0; |
95 | pp->FieldOrderCntList[i][1] = 0; |
96 | pp->FrameNumList[i] = 0; |
97 | } |
98 | } |
99 | |
100 | pp->wFrameWidthInMbsMinus1 = h->mb_width - 1; |
101 | pp->wFrameHeightInMbsMinus1 = h->mb_height - 1; |
102 | pp->num_ref_frames = sps->ref_frame_count; |
103 | |
104 | pp->wBitFields = ((h->picture_structure != PICT_FRAME) << 0) | |
105 | ((sps->mb_aff && |
106 | (h->picture_structure == PICT_FRAME)) << 1) | |
107 | (sps->residual_color_transform_flag << 2) | |
108 | /* sp_for_switch_flag (not implemented by FFmpeg) */ |
109 | (0 << 3) | |
110 | (sps->chroma_format_idc << 4) | |
111 | ((h->nal_ref_idc != 0) << 6) | |
112 | (pps->constrained_intra_pred << 7) | |
113 | (pps->weighted_pred << 8) | |
114 | (pps->weighted_bipred_idc << 9) | |
115 | /* MbsConsecutiveFlag */ |
116 | (1 << 11) | |
117 | (sps->frame_mbs_only_flag << 12) | |
118 | (pps->transform_8x8_mode << 13) | |
119 | ((sps->level_idc >= 31) << 14) | |
120 | /* IntraPicFlag (Modified if we detect a non |
121 | * intra slice in dxva2_h264_decode_slice) */ |
122 | (1 << 15); |
123 | |
124 | pp->bit_depth_luma_minus8 = sps->bit_depth_luma - 8; |
125 | pp->bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8; |
126 | if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG) |
127 | pp->Reserved16Bits = 0; |
128 | else if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO) |
129 | pp->Reserved16Bits = 0x34c; |
130 | else |
131 | pp->Reserved16Bits = 3; /* FIXME is there a way to detect the right mode ? */ |
132 | pp->StatusReportFeedbackNumber = 1 + DXVA_CONTEXT_REPORT_ID(avctx, ctx)++; |
133 | pp->CurrFieldOrderCnt[0] = 0; |
134 | if ((h->picture_structure & PICT_TOP_FIELD) && |
135 | current_picture->field_poc[0] != INT_MAX) |
136 | pp->CurrFieldOrderCnt[0] = current_picture->field_poc[0]; |
137 | pp->CurrFieldOrderCnt[1] = 0; |
138 | if ((h->picture_structure & PICT_BOTTOM_FIELD) && |
139 | current_picture->field_poc[1] != INT_MAX) |
140 | pp->CurrFieldOrderCnt[1] = current_picture->field_poc[1]; |
141 | pp->pic_init_qs_minus26 = pps->init_qs - 26; |
142 | pp->chroma_qp_index_offset = pps->chroma_qp_index_offset[0]; |
143 | pp->second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1]; |
144 | pp->ContinuationFlag = 1; |
145 | pp->pic_init_qp_minus26 = pps->init_qp - 26; |
146 | pp->num_ref_idx_l0_active_minus1 = pps->ref_count[0] - 1; |
147 | pp->num_ref_idx_l1_active_minus1 = pps->ref_count[1] - 1; |
148 | pp->Reserved8BitsA = 0; |
149 | pp->frame_num = h->poc.frame_num; |
150 | pp->log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4; |
151 | pp->pic_order_cnt_type = sps->poc_type; |
152 | if (sps->poc_type == 0) |
153 | pp->log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4; |
154 | else if (sps->poc_type == 1) |
155 | pp->delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag; |
156 | pp->direct_8x8_inference_flag = sps->direct_8x8_inference_flag; |
157 | pp->entropy_coding_mode_flag = pps->cabac; |
158 | pp->pic_order_present_flag = pps->pic_order_present; |
159 | pp->num_slice_groups_minus1 = pps->slice_group_count - 1; |
160 | pp->slice_group_map_type = pps->mb_slice_group_map_type; |
161 | pp->deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present; |
162 | pp->redundant_pic_cnt_present_flag= pps->redundant_pic_cnt_present; |
163 | pp->Reserved8BitsB = 0; |
164 | pp->slice_group_change_rate_minus1= 0; /* XXX not implemented by FFmpeg */ |
165 | //pp->SliceGroupMap[810]; /* XXX not implemented by FFmpeg */ |
166 | } |
167 | |
168 | static void fill_scaling_lists(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm) |
169 | { |
170 | const PPS *pps = h->ps.pps; |
171 | unsigned i, j; |
172 | memset(qm, 0, sizeof(*qm)); |
173 | if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG) { |
174 | for (i = 0; i < 6; i++) |
175 | for (j = 0; j < 16; j++) |
176 | qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][j]; |
177 | |
178 | for (i = 0; i < 64; i++) { |
179 | qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][i]; |
180 | qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][i]; |
181 | } |
182 | } else { |
183 | for (i = 0; i < 6; i++) |
184 | for (j = 0; j < 16; j++) |
185 | qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][ff_zigzag_scan[j]]; |
186 | |
187 | for (i = 0; i < 64; i++) { |
188 | qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][ff_zigzag_direct[i]]; |
189 | qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][ff_zigzag_direct[i]]; |
190 | } |
191 | } |
192 | } |
193 | |
194 | static int is_slice_short(const AVCodecContext *avctx, AVDXVAContext *ctx) |
195 | { |
196 | assert(DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 1 || |
197 | DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 2); |
198 | return DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 2; |
199 | } |
200 | |
201 | static void fill_slice_short(DXVA_Slice_H264_Short *slice, |
202 | unsigned position, unsigned size) |
203 | { |
204 | memset(slice, 0, sizeof(*slice)); |
205 | slice->BSNALunitDataLocation = position; |
206 | slice->SliceBytesInBuffer = size; |
207 | slice->wBadSliceChopping = 0; |
208 | } |
209 | |
210 | static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index) |
211 | { |
212 | int i; |
213 | for (i = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) { |
214 | if ((pp->RefFrameList[i].bPicEntry & 0x7f) == surface_index) |
215 | return i; |
216 | } |
217 | return 0x7f; |
218 | } |
219 | |
220 | static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice, |
221 | const DXVA_PicParams_H264 *pp, unsigned position, unsigned size) |
222 | { |
223 | const H264Context *h = avctx->priv_data; |
224 | H264SliceContext *sl = &h->slice_ctx[0]; |
225 | AVDXVAContext *ctx = avctx->hwaccel_context; |
226 | unsigned list; |
227 | |
228 | memset(slice, 0, sizeof(*slice)); |
229 | slice->BSNALunitDataLocation = position; |
230 | slice->SliceBytesInBuffer = size; |
231 | slice->wBadSliceChopping = 0; |
232 | |
233 | slice->first_mb_in_slice = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x; |
234 | slice->NumMbsForSlice = 0; /* XXX it is set once we have all slices */ |
235 | slice->BitOffsetToSliceData = get_bits_count(&sl->gb) - 8; |
236 | slice->slice_type = ff_h264_get_slice_type(sl); |
237 | if (sl->slice_type_fixed) |
238 | slice->slice_type += 5; |
239 | slice->luma_log2_weight_denom = sl->pwt.luma_log2_weight_denom; |
240 | slice->chroma_log2_weight_denom = sl->pwt.chroma_log2_weight_denom; |
241 | if (sl->list_count > 0) |
242 | slice->num_ref_idx_l0_active_minus1 = sl->ref_count[0] - 1; |
243 | if (sl->list_count > 1) |
244 | slice->num_ref_idx_l1_active_minus1 = sl->ref_count[1] - 1; |
245 | slice->slice_alpha_c0_offset_div2 = sl->slice_alpha_c0_offset / 2; |
246 | slice->slice_beta_offset_div2 = sl->slice_beta_offset / 2; |
247 | slice->Reserved8Bits = 0; |
248 | |
249 | for (list = 0; list < 2; list++) { |
250 | unsigned i; |
251 | for (i = 0; i < FF_ARRAY_ELEMS(slice->RefPicList[list]); i++) { |
252 | if (list < sl->list_count && i < sl->ref_count[list]) { |
253 | const H264Picture *r = sl->ref_list[list][i].parent; |
254 | unsigned plane; |
255 | unsigned index; |
256 | if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO) |
257 | index = ff_dxva2_get_surface_index(avctx, ctx, r->f); |
258 | else |
259 | index = get_refpic_index(pp, ff_dxva2_get_surface_index(avctx, ctx, r->f)); |
260 | fill_picture_entry(&slice->RefPicList[list][i], index, |
261 | sl->ref_list[list][i].reference == PICT_BOTTOM_FIELD); |
262 | for (plane = 0; plane < 3; plane++) { |
263 | int w, o; |
264 | if (plane == 0 && sl->pwt.luma_weight_flag[list]) { |
265 | w = sl->pwt.luma_weight[i][list][0]; |
266 | o = sl->pwt.luma_weight[i][list][1]; |
267 | } else if (plane >= 1 && sl->pwt.chroma_weight_flag[list]) { |
268 | w = sl->pwt.chroma_weight[i][list][plane-1][0]; |
269 | o = sl->pwt.chroma_weight[i][list][plane-1][1]; |
270 | } else { |
271 | w = 1 << (plane == 0 ? sl->pwt.luma_log2_weight_denom : |
272 | sl->pwt.chroma_log2_weight_denom); |
273 | o = 0; |
274 | } |
275 | slice->Weights[list][i][plane][0] = w; |
276 | slice->Weights[list][i][plane][1] = o; |
277 | } |
278 | } else { |
279 | unsigned plane; |
280 | slice->RefPicList[list][i].bPicEntry = 0xff; |
281 | for (plane = 0; plane < 3; plane++) { |
282 | slice->Weights[list][i][plane][0] = 0; |
283 | slice->Weights[list][i][plane][1] = 0; |
284 | } |
285 | } |
286 | } |
287 | } |
288 | slice->slice_qs_delta = 0; /* XXX not implemented by FFmpeg */ |
289 | slice->slice_qp_delta = sl->qscale - h->ps.pps->init_qp; |
290 | slice->redundant_pic_cnt = sl->redundant_pic_count; |
291 | if (sl->slice_type == AV_PICTURE_TYPE_B) |
292 | slice->direct_spatial_mv_pred_flag = sl->direct_spatial_mv_pred; |
293 | slice->cabac_init_idc = h->ps.pps->cabac ? sl->cabac_init_idc : 0; |
294 | if (sl->deblocking_filter < 2) |
295 | slice->disable_deblocking_filter_idc = 1 - sl->deblocking_filter; |
296 | else |
297 | slice->disable_deblocking_filter_idc = sl->deblocking_filter; |
298 | slice->slice_id = h->current_slice - 1; |
299 | } |
300 | |
301 | static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, |
302 | DECODER_BUFFER_DESC *bs, |
303 | DECODER_BUFFER_DESC *sc) |
304 | { |
305 | const H264Context *h = avctx->priv_data; |
306 | const unsigned mb_count = h->mb_width * h->mb_height; |
307 | AVDXVAContext *ctx = avctx->hwaccel_context; |
308 | const H264Picture *current_picture = h->cur_pic_ptr; |
309 | struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private; |
310 | DXVA_Slice_H264_Short *slice = NULL; |
311 | void *dxva_data_ptr = NULL; |
312 | uint8_t *dxva_data, *current, *end; |
313 | unsigned dxva_size = 0; |
314 | void *slice_data; |
315 | unsigned slice_size; |
316 | unsigned padding; |
317 | unsigned i; |
318 | unsigned type; |
319 | |
320 | /* Create an annex B bitstream buffer with only slice NAL and finalize slice */ |
321 | #if CONFIG_D3D11VA |
322 | if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) { |
323 | type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM; |
324 | if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, |
325 | D3D11VA_CONTEXT(ctx)->decoder, |
326 | type, |
327 | &dxva_size, &dxva_data_ptr))) |
328 | return -1; |
329 | } |
330 | #endif |
331 | #if CONFIG_DXVA2 |
332 | if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) { |
333 | type = DXVA2_BitStreamDateBufferType; |
334 | if (FAILED(IDirectXVideoDecoder_GetBuffer(DXVA2_CONTEXT(ctx)->decoder, |
335 | type, |
336 | &dxva_data_ptr, &dxva_size))) |
337 | return -1; |
338 | } |
339 | #endif |
340 | |
341 | dxva_data = dxva_data_ptr; |
342 | current = dxva_data; |
343 | end = dxva_data + dxva_size; |
344 | |
345 | for (i = 0; i < ctx_pic->slice_count; i++) { |
346 | static const uint8_t start_code[] = { 0, 0, 1 }; |
347 | static const unsigned start_code_size = sizeof(start_code); |
348 | unsigned position, size; |
349 | |
350 | assert(offsetof(DXVA_Slice_H264_Short, BSNALunitDataLocation) == |
351 | offsetof(DXVA_Slice_H264_Long, BSNALunitDataLocation)); |
352 | assert(offsetof(DXVA_Slice_H264_Short, SliceBytesInBuffer) == |
353 | offsetof(DXVA_Slice_H264_Long, SliceBytesInBuffer)); |
354 | |
355 | if (is_slice_short(avctx, ctx)) |
356 | slice = &ctx_pic->slice_short[i]; |
357 | else |
358 | slice = (DXVA_Slice_H264_Short*)&ctx_pic->slice_long[i]; |
359 | |
360 | position = slice->BSNALunitDataLocation; |
361 | size = slice->SliceBytesInBuffer; |
362 | if (start_code_size + size > end - current) { |
363 | av_log(avctx, AV_LOG_ERROR, "Failed to build bitstream"); |
364 | break; |
365 | } |
366 | |
367 | slice->BSNALunitDataLocation = current - dxva_data; |
368 | slice->SliceBytesInBuffer = start_code_size + size; |
369 | |
370 | if (!is_slice_short(avctx, ctx)) { |
371 | DXVA_Slice_H264_Long *slice_long = (DXVA_Slice_H264_Long*)slice; |
372 | if (i < ctx_pic->slice_count - 1) |
373 | slice_long->NumMbsForSlice = |
374 | slice_long[1].first_mb_in_slice - slice_long[0].first_mb_in_slice; |
375 | else |
376 | slice_long->NumMbsForSlice = mb_count - slice_long->first_mb_in_slice; |
377 | } |
378 | |
379 | memcpy(current, start_code, start_code_size); |
380 | current += start_code_size; |
381 | |
382 | memcpy(current, &ctx_pic->bitstream[position], size); |
383 | current += size; |
384 | } |
385 | padding = FFMIN(128 - ((current - dxva_data) & 127), end - current); |
386 | if (slice && padding > 0) { |
387 | memset(current, 0, padding); |
388 | current += padding; |
389 | |
390 | slice->SliceBytesInBuffer += padding; |
391 | } |
392 | #if CONFIG_D3D11VA |
393 | if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) |
394 | if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type))) |
395 | return -1; |
396 | #endif |
397 | #if CONFIG_DXVA2 |
398 | if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) |
399 | if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type))) |
400 | return -1; |
401 | #endif |
402 | if (i < ctx_pic->slice_count) |
403 | return -1; |
404 | |
405 | #if CONFIG_D3D11VA |
406 | if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) { |
407 | D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs; |
408 | memset(dsc11, 0, sizeof(*dsc11)); |
409 | dsc11->BufferType = type; |
410 | dsc11->DataSize = current - dxva_data; |
411 | dsc11->NumMBsInBuffer = mb_count; |
412 | |
413 | type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL; |
414 | |
415 | av_assert0((dsc11->DataSize & 127) == 0); |
416 | } |
417 | #endif |
418 | #if CONFIG_DXVA2 |
419 | if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) { |
420 | DXVA2_DecodeBufferDesc *dsc2 = bs; |
421 | memset(dsc2, 0, sizeof(*dsc2)); |
422 | dsc2->CompressedBufferType = type; |
423 | dsc2->DataSize = current - dxva_data; |
424 | dsc2->NumMBsInBuffer = mb_count; |
425 | |
426 | type = DXVA2_SliceControlBufferType; |
427 | |
428 | av_assert0((dsc2->DataSize & 127) == 0); |
429 | } |
430 | #endif |
431 | |
432 | if (is_slice_short(avctx, ctx)) { |
433 | slice_data = ctx_pic->slice_short; |
434 | slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_short); |
435 | } else { |
436 | slice_data = ctx_pic->slice_long; |
437 | slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_long); |
438 | } |
439 | return ff_dxva2_commit_buffer(avctx, ctx, sc, |
440 | type, |
441 | slice_data, slice_size, mb_count); |
442 | } |
443 | |
444 | |
445 | static int dxva2_h264_start_frame(AVCodecContext *avctx, |
446 | av_unused const uint8_t *buffer, |
447 | av_unused uint32_t size) |
448 | { |
449 | const H264Context *h = avctx->priv_data; |
450 | AVDXVAContext *ctx = avctx->hwaccel_context; |
451 | struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->hwaccel_picture_private; |
452 | |
453 | if (!DXVA_CONTEXT_VALID(avctx, ctx)) |
454 | return -1; |
455 | assert(ctx_pic); |
456 | |
457 | /* Fill up DXVA_PicParams_H264 */ |
458 | fill_picture_parameters(avctx, ctx, h, &ctx_pic->pp); |
459 | |
460 | /* Fill up DXVA_Qmatrix_H264 */ |
461 | fill_scaling_lists(avctx, ctx, h, &ctx_pic->qm); |
462 | |
463 | ctx_pic->slice_count = 0; |
464 | ctx_pic->bitstream_size = 0; |
465 | ctx_pic->bitstream = NULL; |
466 | return 0; |
467 | } |
468 | |
469 | static int dxva2_h264_decode_slice(AVCodecContext *avctx, |
470 | const uint8_t *buffer, |
471 | uint32_t size) |
472 | { |
473 | const H264Context *h = avctx->priv_data; |
474 | const H264SliceContext *sl = &h->slice_ctx[0]; |
475 | AVDXVAContext *ctx = avctx->hwaccel_context; |
476 | const H264Picture *current_picture = h->cur_pic_ptr; |
477 | struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private; |
478 | unsigned position; |
479 | |
480 | if (ctx_pic->slice_count >= MAX_SLICES) |
481 | return -1; |
482 | |
483 | if (!ctx_pic->bitstream) |
484 | ctx_pic->bitstream = buffer; |
485 | ctx_pic->bitstream_size += size; |
486 | |
487 | position = buffer - ctx_pic->bitstream; |
488 | if (is_slice_short(avctx, ctx)) |
489 | fill_slice_short(&ctx_pic->slice_short[ctx_pic->slice_count], |
490 | position, size); |
491 | else |
492 | fill_slice_long(avctx, &ctx_pic->slice_long[ctx_pic->slice_count], |
493 | &ctx_pic->pp, position, size); |
494 | ctx_pic->slice_count++; |
495 | |
496 | if (sl->slice_type != AV_PICTURE_TYPE_I && sl->slice_type != AV_PICTURE_TYPE_SI) |
497 | ctx_pic->pp.wBitFields &= ~(1 << 15); /* Set IntraPicFlag to 0 */ |
498 | return 0; |
499 | } |
500 | |
501 | static int dxva2_h264_end_frame(AVCodecContext *avctx) |
502 | { |
503 | H264Context *h = avctx->priv_data; |
504 | H264SliceContext *sl = &h->slice_ctx[0]; |
505 | struct dxva2_picture_context *ctx_pic = |
506 | h->cur_pic_ptr->hwaccel_picture_private; |
507 | int ret; |
508 | |
509 | if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0) |
510 | return -1; |
511 | ret = ff_dxva2_common_end_frame(avctx, h->cur_pic_ptr->f, |
512 | &ctx_pic->pp, sizeof(ctx_pic->pp), |
513 | &ctx_pic->qm, sizeof(ctx_pic->qm), |
514 | commit_bitstream_and_slice_buffer); |
515 | if (!ret) |
516 | ff_h264_draw_horiz_band(h, sl, 0, h->avctx->height); |
517 | return ret; |
518 | } |
519 | |
520 | #if CONFIG_H264_DXVA2_HWACCEL |
521 | AVHWAccel ff_h264_dxva2_hwaccel = { |
522 | .name = "h264_dxva2", |
523 | .type = AVMEDIA_TYPE_VIDEO, |
524 | .id = AV_CODEC_ID_H264, |
525 | .pix_fmt = AV_PIX_FMT_DXVA2_VLD, |
526 | .start_frame = dxva2_h264_start_frame, |
527 | .decode_slice = dxva2_h264_decode_slice, |
528 | .end_frame = dxva2_h264_end_frame, |
529 | .frame_priv_data_size = sizeof(struct dxva2_picture_context), |
530 | }; |
531 | #endif |
532 | |
533 | #if CONFIG_H264_D3D11VA_HWACCEL |
534 | AVHWAccel ff_h264_d3d11va_hwaccel = { |
535 | .name = "h264_d3d11va", |
536 | .type = AVMEDIA_TYPE_VIDEO, |
537 | .id = AV_CODEC_ID_H264, |
538 | .pix_fmt = AV_PIX_FMT_D3D11VA_VLD, |
539 | .start_frame = dxva2_h264_start_frame, |
540 | .decode_slice = dxva2_h264_decode_slice, |
541 | .end_frame = dxva2_h264_end_frame, |
542 | .frame_priv_data_size = sizeof(struct dxva2_picture_context), |
543 | }; |
544 | #endif |
545 |