FFmpeg: libavcodec/dxva2_h264.c Source File

FFmpeg

[フレーム]

libavcodec

dxva2_h264.c

Go to the documentation of this file.

1 /*

2 * DXVA2 H.264 HW acceleration.

3 *

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 */

23 #include "libavutil/avassert.h"

25 #include "dxva2_internal.h"

26 #include "h264dec.h"

27 #include "h264data.h"

28 #include "h264_ps.h"

29 #include "mpegutils.h"

31 struct dxva2_picture_context {

32 DXVA_PicParams_H264 pp;

33 DXVA_Qmatrix_H264 qm;

34 unsigned slice_count;

35 DXVA_Slice_H264_Short slice_short[MAX_SLICES];

36 DXVA_Slice_H264_Long slice_long[MAX_SLICES];

37 const uint8_t *bitstream;

38 unsigned bitstream_size;

39 };

41 static void fill_picture_entry(DXVA_PicEntry_H264 *pic,

42 unsigned index, unsigned flag)

43 {

44 assert((index&0x7f) == index && (flag&0x01) == flag);

45 pic->bPicEntry = index | (flag << 7);

46 }

48 static void fill_picture_parameters(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h,

49 DXVA_PicParams_H264 *pp)

50 {

51 const H264Picture *current_picture = h->cur_pic_ptr;

52 const SPS *sps = h->ps.sps;

53 const PPS *pps = h->ps.pps;

54 int i, j;

56 memset(pp, 0, sizeof(*pp));

57 /* Configure current picture */

58 fill_picture_entry(&pp->CurrPic,

59 ff_dxva2_get_surface_index(avctx, ctx, current_picture->f),

60 h->picture_structure == PICT_BOTTOM_FIELD);

61 /* Configure the set of references */

62 pp->UsedForReferenceFlags = 0;

63 pp->NonExistingFrameFlags = 0;

64 for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) {

65 const H264Picture *r;

66 if (j < h->short_ref_count) {

67 r = h->short_ref[j++];

68 } else {

69 r = NULL;

70 while (!r && j < h->short_ref_count + 16)

71 r = h->long_ref[j++ - h->short_ref_count];

72 }

73 if (r) {

74 fill_picture_entry(&pp->RefFrameList[i],

75 ff_dxva2_get_surface_index(avctx, ctx, r->f),

76 r->long_ref != 0);

78 if ((r->reference & PICT_TOP_FIELD) && r->field_poc[0] != INT_MAX)

79 pp->FieldOrderCntList[i][0] = r->field_poc[0];

80 if ((r->reference & PICT_BOTTOM_FIELD) && r->field_poc[1] != INT_MAX)

81 pp->FieldOrderCntList[i][1] = r->field_poc[1];

83 pp->FrameNumList[i] = r->long_ref ? r->pic_id : r->frame_num;

84 if (r->reference & PICT_TOP_FIELD)

85 pp->UsedForReferenceFlags |= 1 << (2*i + 0);

86 if (r->reference & PICT_BOTTOM_FIELD)

87 pp->UsedForReferenceFlags |= 1 << (2*i + 1);

88 } else {

89 pp->RefFrameList[i].bPicEntry = 0xff;

90 pp->FieldOrderCntList[i][0] = 0;

91 pp->FieldOrderCntList[i][1] = 0;

92 pp->FrameNumList[i] = 0;

93 }

94 }

96 pp->wFrameWidthInMbsMinus1 = h->mb_width - 1;

97 pp->wFrameHeightInMbsMinus1 = h->mb_height - 1;

98 pp->num_ref_frames = sps->ref_frame_count;

100 pp->wBitFields = ((h->picture_structure != PICT_FRAME) << 0) |

101 ((sps->mb_aff &&

102 (h->picture_structure == PICT_FRAME)) << 1) |

103 (sps->residual_color_transform_flag << 2) |

104 /* sp_for_switch_flag (not implemented by FFmpeg) */

105 (0 << 3) |

106 (sps->chroma_format_idc << 4) |

107 ((h->nal_ref_idc != 0) << 6) |

108 (pps->constrained_intra_pred << 7) |

109 (pps->weighted_pred << 8) |

110 (pps->weighted_bipred_idc << 9) |

111 /* MbsConsecutiveFlag */

112 (1 << 11) |

113 (sps->frame_mbs_only_flag << 12) |

114 (pps->transform_8x8_mode << 13) |

115 ((sps->level_idc >= 31) << 14) |

116 /* IntraPicFlag (Modified if we detect a non

117 * intra slice in dxva2_h264_decode_slice) */

118 (1 << 15);

119

120 pp->bit_depth_luma_minus8 = sps->bit_depth_luma - 8;

121 pp->bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8;

122 if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG)

123 pp->Reserved16Bits = 0;

124 else if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)

125 pp->Reserved16Bits = 0x34c;

126 else

127 pp->Reserved16Bits = 3; /* FIXME is there a way to detect the right mode ? */

128 pp->StatusReportFeedbackNumber = 1 + DXVA_CONTEXT_REPORT_ID(avctx, ctx)++;

129 pp->CurrFieldOrderCnt[0] = 0;

130 if ((h->picture_structure & PICT_TOP_FIELD) &&

131 current_picture->field_poc[0] != INT_MAX)

132 pp->CurrFieldOrderCnt[0] = current_picture->field_poc[0];

133 pp->CurrFieldOrderCnt[1] = 0;

134 if ((h->picture_structure & PICT_BOTTOM_FIELD) &&

135 current_picture->field_poc[1] != INT_MAX)

136 pp->CurrFieldOrderCnt[1] = current_picture->field_poc[1];

137 pp->pic_init_qs_minus26 = pps->init_qs - 26;

138 pp->chroma_qp_index_offset = pps->chroma_qp_index_offset[0];

139 pp->second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1];

140 pp->ContinuationFlag = 1;

141 pp->pic_init_qp_minus26 = pps->init_qp - 26;

142 pp->num_ref_idx_l0_active_minus1 = pps->ref_count[0] - 1;

143 pp->num_ref_idx_l1_active_minus1 = pps->ref_count[1] - 1;

144 pp->Reserved8BitsA = 0;

145 pp->frame_num = h->poc.frame_num;

146 pp->log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4;

147 pp->pic_order_cnt_type = sps->poc_type;

148 if (sps->poc_type == 0)

149 pp->log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4;

150 else if (sps->poc_type == 1)

151 pp->delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag;

152 pp->direct_8x8_inference_flag = sps->direct_8x8_inference_flag;

153 pp->entropy_coding_mode_flag = pps->cabac;

154 pp->pic_order_present_flag = pps->pic_order_present;

155 pp->num_slice_groups_minus1 = pps->slice_group_count - 1;

156 pp->slice_group_map_type = pps->mb_slice_group_map_type;

157 pp->deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present;

158 pp->redundant_pic_cnt_present_flag= pps->redundant_pic_cnt_present;

159 pp->Reserved8BitsB = 0;

160 pp->slice_group_change_rate_minus1= 0; /* XXX not implemented by FFmpeg */

161 //pp->SliceGroupMap[810]; /* XXX not implemented by FFmpeg */

162 }

163

164 static void fill_scaling_lists(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)

165 {

166 const PPS *pps = h->ps.pps;

167 unsigned i, j;

168 memset(qm, 0, sizeof(*qm));

169 if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG) {

170 for (i = 0; i < 6; i++)

171 for (j = 0; j < 16; j++)

172 qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][j];

173

174 for (i = 0; i < 64; i++) {

175 qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][i];

176 qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][i];

177 }

178 } else {

179 for (i = 0; i < 6; i++)

180 for (j = 0; j < 16; j++)

181 qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][ff_zigzag_scan[j]];

182

183 for (i = 0; i < 64; i++) {

184 qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][ff_zigzag_direct[i]];

185 qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][ff_zigzag_direct[i]];

186 }

187 }

188 }

189

190 static int is_slice_short(const AVCodecContext *avctx, AVDXVAContext *ctx)

191 {

192 assert(DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 1 ||

193 DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 2);

194 return DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx) == 2;

195 }

196

197 static void fill_slice_short(DXVA_Slice_H264_Short *slice,

198 unsigned position, unsigned size)

199 {

200 memset(slice, 0, sizeof(*slice));

201 slice->BSNALunitDataLocation = position;

202 slice->SliceBytesInBuffer = size;

203 slice->wBadSliceChopping = 0;

204 }

205

206 static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index)

207 {

208 int i;

209 for (i = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) {

210 if ((pp->RefFrameList[i].bPicEntry & 0x7f) == surface_index)

211 return i;

212 }

213 return 0x7f;

214 }

215

216 static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,

217 const DXVA_PicParams_H264 *pp, unsigned position, unsigned size)

218 {

219 const H264Context *h = avctx->priv_data;

220 H264SliceContext *sl = &h->slice_ctx[0];

221 AVDXVAContext *ctx = DXVA_CONTEXT(avctx);

222 unsigned list;

223

224 memset(slice, 0, sizeof(*slice));

225 slice->BSNALunitDataLocation = position;

226 slice->SliceBytesInBuffer = size;

227 slice->wBadSliceChopping = 0;

228

229 slice->first_mb_in_slice = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x;

230 slice->NumMbsForSlice = 0; /* XXX it is set once we have all slices */

231 slice->BitOffsetToSliceData = get_bits_count(&sl->gb) - 8;

232 slice->slice_type = ff_h264_get_slice_type(sl);

233 if (sl->slice_type_fixed)

234 slice->slice_type += 5;

235 slice->luma_log2_weight_denom = sl->pwt.luma_log2_weight_denom;

236 slice->chroma_log2_weight_denom = sl->pwt.chroma_log2_weight_denom;

237 if (sl->list_count > 0)

238 slice->num_ref_idx_l0_active_minus1 = sl->ref_count[0] - 1;

239 if (sl->list_count > 1)

240 slice->num_ref_idx_l1_active_minus1 = sl->ref_count[1] - 1;

241 slice->slice_alpha_c0_offset_div2 = sl->slice_alpha_c0_offset / 2;

242 slice->slice_beta_offset_div2 = sl->slice_beta_offset / 2;

243 slice->Reserved8Bits = 0;

244

245 for (list = 0; list < 2; list++) {

246 unsigned i;

247 for (i = 0; i < FF_ARRAY_ELEMS(slice->RefPicList[list]); i++) {

248 if (list < sl->list_count && i < sl->ref_count[list]) {

249 const H264Picture *r = sl->ref_list[list][i].parent;

250 unsigned plane;

251 unsigned index;

252 if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)

253 index = ff_dxva2_get_surface_index(avctx, ctx, r->f);

254 else

255 index = get_refpic_index(pp, ff_dxva2_get_surface_index(avctx, ctx, r->f));

256 fill_picture_entry(&slice->RefPicList[list][i], index,

257 sl->ref_list[list][i].reference == PICT_BOTTOM_FIELD);

258 for (plane = 0; plane < 3; plane++) {

259 int w, o;

260 if (plane == 0 && sl->pwt.luma_weight_flag[list]) {

261 w = sl->pwt.luma_weight[i][list][0];

262 o = sl->pwt.luma_weight[i][list][1];

263 } else if (plane >= 1 && sl->pwt.chroma_weight_flag[list]) {

264 w = sl->pwt.chroma_weight[i][list][plane-1][0];

265 o = sl->pwt.chroma_weight[i][list][plane-1][1];

266 } else {

267 w = 1 << (plane == 0 ? sl->pwt.luma_log2_weight_denom :

268 sl->pwt.chroma_log2_weight_denom);

269 o = 0;

270 }

271 slice->Weights[list][i][plane][0] = w;

272 slice->Weights[list][i][plane][1] = o;

273 }

274 } else {

275 unsigned plane;

276 slice->RefPicList[list][i].bPicEntry = 0xff;

277 for (plane = 0; plane < 3; plane++) {

278 slice->Weights[list][i][plane][0] = 0;

279 slice->Weights[list][i][plane][1] = 0;

280 }

281 }

282 }

283 }

284 slice->slice_qs_delta = 0; /* XXX not implemented by FFmpeg */

285 slice->slice_qp_delta = sl->qscale - h->ps.pps->init_qp;

286 slice->redundant_pic_cnt = sl->redundant_pic_count;

287 if (sl->slice_type == AV_PICTURE_TYPE_B)

288 slice->direct_spatial_mv_pred_flag = sl->direct_spatial_mv_pred;

289 slice->cabac_init_idc = h->ps.pps->cabac ? sl->cabac_init_idc : 0;

290 if (sl->deblocking_filter < 2)

291 slice->disable_deblocking_filter_idc = 1 - sl->deblocking_filter;

292 else

293 slice->disable_deblocking_filter_idc = sl->deblocking_filter;

294 slice->slice_id = h->current_slice - 1;

295 }

296

297 static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,

298 DECODER_BUFFER_DESC *bs,

299 DECODER_BUFFER_DESC *sc)

300 {

301 const H264Context *h = avctx->priv_data;

302 const unsigned mb_count = h->mb_width * h->mb_height;

303 AVDXVAContext *ctx = DXVA_CONTEXT(avctx);

304 const H264Picture *current_picture = h->cur_pic_ptr;

305 struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;

306 DXVA_Slice_H264_Short *slice = NULL;

307 void *dxva_data_ptr = NULL;

308 uint8_t *dxva_data, *current, *end;

309 unsigned dxva_size = 0;

310 void *slice_data;

311 unsigned slice_size;

312 unsigned padding;

313 unsigned i;

314 unsigned type;

315

316 /* Create an annex B bitstream buffer with only slice NAL and finalize slice */

317 #if CONFIG_D3D11VA

318 if (ff_dxva2_is_d3d11(avctx)) {

319 type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;

320 if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,

321 D3D11VA_CONTEXT(ctx)->decoder,

322 type,

323 &dxva_size, &dxva_data_ptr)))

324 return -1;

325 }

326 #endif

327 #if CONFIG_DXVA2

328 if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {

329 type = DXVA2_BitStreamDateBufferType;

330 if (FAILED(IDirectXVideoDecoder_GetBuffer(DXVA2_CONTEXT(ctx)->decoder,

331 type,

332 &dxva_data_ptr, &dxva_size)))

333 return -1;

334 }

335 #endif

336

337 dxva_data = dxva_data_ptr;

338 current = dxva_data;

339 end = dxva_data + dxva_size;

340

341 for (i = 0; i < ctx_pic->slice_count; i++) {

342 static const uint8_t start_code[] = { 0, 0, 1 };

343 static const unsigned start_code_size = sizeof(start_code);

344 unsigned position, size;

345

346 assert(offsetof(DXVA_Slice_H264_Short, BSNALunitDataLocation) ==

347 offsetof(DXVA_Slice_H264_Long, BSNALunitDataLocation));

348 assert(offsetof(DXVA_Slice_H264_Short, SliceBytesInBuffer) ==

349 offsetof(DXVA_Slice_H264_Long, SliceBytesInBuffer));

350

351 if (is_slice_short(avctx, ctx))

352 slice = &ctx_pic->slice_short[i];

353 else

354 slice = (DXVA_Slice_H264_Short*)&ctx_pic->slice_long[i];

355

356 position = slice->BSNALunitDataLocation;

357 size = slice->SliceBytesInBuffer;

358 if (start_code_size + size > end - current) {

359 av_log(avctx, AV_LOG_ERROR, "Failed to build bitstream");

360 break;

361 }

362

363 slice->BSNALunitDataLocation = current - dxva_data;

364 slice->SliceBytesInBuffer = start_code_size + size;

365

366 if (!is_slice_short(avctx, ctx)) {

367 DXVA_Slice_H264_Long *slice_long = (DXVA_Slice_H264_Long*)slice;

368 if (i < ctx_pic->slice_count - 1)

369 slice_long->NumMbsForSlice =

370 slice_long[1].first_mb_in_slice - slice_long[0].first_mb_in_slice;

371 else

372 slice_long->NumMbsForSlice = mb_count - slice_long->first_mb_in_slice;

373 }

374

375 memcpy(current, start_code, start_code_size);

376 current += start_code_size;

377

378 memcpy(current, &ctx_pic->bitstream[position], size);

379 current += size;

380 }

381 padding = FFMIN(128 - ((current - dxva_data) & 127), end - current);

382 if (slice && padding > 0) {

383 memset(current, 0, padding);

384 current += padding;

385

386 slice->SliceBytesInBuffer += padding;

387 }

388 #if CONFIG_D3D11VA

389 if (ff_dxva2_is_d3d11(avctx))

390 if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))

391 return -1;

392 #endif

393 #if CONFIG_DXVA2

394 if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)

395 if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type)))

396 return -1;

397 #endif

398 if (i < ctx_pic->slice_count)

399 return -1;

400

401 #if CONFIG_D3D11VA

402 if (ff_dxva2_is_d3d11(avctx)) {

403 D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;

404 memset(dsc11, 0, sizeof(*dsc11));

405 dsc11->BufferType = type;

406 dsc11->DataSize = current - dxva_data;

407 dsc11->NumMBsInBuffer = mb_count;

408

409 type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;

410

411 av_assert0((dsc11->DataSize & 127) == 0);

412 }

413 #endif

414 #if CONFIG_DXVA2

415 if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {

416 DXVA2_DecodeBufferDesc *dsc2 = bs;

417 memset(dsc2, 0, sizeof(*dsc2));

418 dsc2->CompressedBufferType = type;

419 dsc2->DataSize = current - dxva_data;

420 dsc2->NumMBsInBuffer = mb_count;

421

422 type = DXVA2_SliceControlBufferType;

423

424 av_assert0((dsc2->DataSize & 127) == 0);

425 }

426 #endif

427

428 if (is_slice_short(avctx, ctx)) {

429 slice_data = ctx_pic->slice_short;

430 slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_short);

431 } else {

432 slice_data = ctx_pic->slice_long;

433 slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_long);

434 }

435 return ff_dxva2_commit_buffer(avctx, ctx, sc,

436 type,

437 slice_data, slice_size, mb_count);

438 }

439

440

441 static int dxva2_h264_start_frame(AVCodecContext *avctx,

442 av_unused const uint8_t *buffer,

443 av_unused uint32_t size)

444 {

445 const H264Context *h = avctx->priv_data;

446 AVDXVAContext *ctx = DXVA_CONTEXT(avctx);

447 struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->hwaccel_picture_private;

448

449 if (!DXVA_CONTEXT_VALID(avctx, ctx))

450 return -1;

451 assert(ctx_pic);

452

453 /* Fill up DXVA_PicParams_H264 */

454 fill_picture_parameters(avctx, ctx, h, &ctx_pic->pp);

455

456 /* Fill up DXVA_Qmatrix_H264 */

457 fill_scaling_lists(avctx, ctx, h, &ctx_pic->qm);

458

459 ctx_pic->slice_count = 0;

460 ctx_pic->bitstream_size = 0;

461 ctx_pic->bitstream = NULL;

462 return 0;

463 }

464

465 static int dxva2_h264_decode_slice(AVCodecContext *avctx,

466 const uint8_t *buffer,

467 uint32_t size)

468 {

469 const H264Context *h = avctx->priv_data;

470 const H264SliceContext *sl = &h->slice_ctx[0];

471 AVDXVAContext *ctx = DXVA_CONTEXT(avctx);

472 const H264Picture *current_picture = h->cur_pic_ptr;

473 struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;

474 unsigned position;

475

476 if (ctx_pic->slice_count >= MAX_SLICES)

477 return -1;

478

479 if (!ctx_pic->bitstream)

480 ctx_pic->bitstream = buffer;

481 ctx_pic->bitstream_size += size;

482

483 position = buffer - ctx_pic->bitstream;

484 if (is_slice_short(avctx, ctx))

485 fill_slice_short(&ctx_pic->slice_short[ctx_pic->slice_count],

486 position, size);

487 else

488 fill_slice_long(avctx, &ctx_pic->slice_long[ctx_pic->slice_count],

489 &ctx_pic->pp, position, size);

490 ctx_pic->slice_count++;

491

492 if (sl->slice_type != AV_PICTURE_TYPE_I && sl->slice_type != AV_PICTURE_TYPE_SI)

493 ctx_pic->pp.wBitFields &= ~(1 << 15); /* Set IntraPicFlag to 0 */

494 return 0;

495 }

496

497 static int dxva2_h264_end_frame(AVCodecContext *avctx)

498 {

499 H264Context *h = avctx->priv_data;

500 H264SliceContext *sl = &h->slice_ctx[0];

501 struct dxva2_picture_context *ctx_pic =

502 h->cur_pic_ptr->hwaccel_picture_private;

503 int ret;

504

505 if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)

506 return -1;

507 ret = ff_dxva2_common_end_frame(avctx, h->cur_pic_ptr->f,

508 &ctx_pic->pp, sizeof(ctx_pic->pp),

509 &ctx_pic->qm, sizeof(ctx_pic->qm),

510 commit_bitstream_and_slice_buffer);

511 if (!ret)

512 ff_h264_draw_horiz_band(h, sl, 0, h->avctx->height);

513 return ret;

514 }

515

516 #if CONFIG_H264_DXVA2_HWACCEL

517 const AVHWAccel ff_h264_dxva2_hwaccel = {

518 .name = "h264_dxva2",

519 .type = AVMEDIA_TYPE_VIDEO,

520 .id = AV_CODEC_ID_H264,

521 .pix_fmt = AV_PIX_FMT_DXVA2_VLD,

522 .init = ff_dxva2_decode_init,

523 .uninit = ff_dxva2_decode_uninit,

524 .start_frame = dxva2_h264_start_frame,

525 .decode_slice = dxva2_h264_decode_slice,

526 .end_frame = dxva2_h264_end_frame,

527 .frame_params = ff_dxva2_common_frame_params,

528 .frame_priv_data_size = sizeof(struct dxva2_picture_context),

529 .priv_data_size = sizeof(FFDXVASharedContext),

530 };

531 #endif

532

533 #if CONFIG_H264_D3D11VA_HWACCEL

534 const 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 .init = ff_dxva2_decode_init,

540 .uninit = ff_dxva2_decode_uninit,

541 .start_frame = dxva2_h264_start_frame,

542 .decode_slice = dxva2_h264_decode_slice,

543 .end_frame = dxva2_h264_end_frame,

544 .frame_params = ff_dxva2_common_frame_params,

545 .frame_priv_data_size = sizeof(struct dxva2_picture_context),

546 .priv_data_size = sizeof(FFDXVASharedContext),

547 };

548 #endif

549

550 #if CONFIG_H264_D3D11VA2_HWACCEL

551 const AVHWAccel ff_h264_d3d11va2_hwaccel = {

552 .name = "h264_d3d11va2",

553 .type = AVMEDIA_TYPE_VIDEO,

554 .id = AV_CODEC_ID_H264,

555 .pix_fmt = AV_PIX_FMT_D3D11,

556 .init = ff_dxva2_decode_init,

557 .uninit = ff_dxva2_decode_uninit,

558 .start_frame = dxva2_h264_start_frame,

559 .decode_slice = dxva2_h264_decode_slice,

560 .end_frame = dxva2_h264_end_frame,

561 .frame_params = ff_dxva2_common_frame_params,

562 .frame_priv_data_size = sizeof(struct dxva2_picture_context),

563 .priv_data_size = sizeof(FFDXVASharedContext),

564 };

565 #endif

SPS::chroma_format_idc

int chroma_format_idc

Definition: h264_ps.h:47

plane

int plane

Definition: avisynth_c.h:422

NULL

#define NULL

Definition: coverity.c:32

H264Picture::long_ref

int long_ref

1->long term reference 0->short term reference

Definition: h264dec.h:154

H264Context::poc

H264POCContext poc

Definition: h264dec.h:460

flag

#define flag(name)

Definition: cbs_h2645.c:346

Definition: vp9dsp_template.c:2038

PPS::weighted_bipred_idc

int weighted_bipred_idc

Definition: h264_ps.h:116

PPS::chroma_qp_index_offset

int chroma_qp_index_offset[2]

Definition: h264_ps.h:119

H264PredWeightTable::luma_weight_flag

int luma_weight_flag[2]

7.4.3.2 luma_weight_lX_flag

Definition: h264_parse.h:35

H264SliceContext

Definition: h264dec.h:177

H264PredWeightTable::chroma_weight

int chroma_weight[48][2][2][2]

Definition: h264_parse.h:39

SPS

Sequence parameter set.

Definition: h264_ps.h:43

PPS::ref_count

unsigned int ref_count[2]

num_ref_idx_l0/1_active_minus1 + 1

Definition: h264_ps.h:114

PPS

Picture parameter set.

Definition: h264_ps.h:108

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

SPS::frame_mbs_only_flag

int frame_mbs_only_flag

Definition: h264_ps.h:61

H264Context::mb_height

int mb_height

Definition: h264dec.h:435

dxva2_picture_context::pp

DXVA_PicParams_H264 pp

Definition: dxva2_h264.c:32

H264Context

H264Context.

Definition: h264dec.h:337

H264Picture::f

AVFrame * f

Definition: h264dec.h:129

H264Context::long_ref

H264Picture * long_ref[32]

Definition: h264dec.h:464

AV_CODEC_ID_H264

Definition: avcodec.h:245

H264Context::picture_structure

int picture_structure

Definition: h264dec.h:407

D3D11VA_CONTEXT

#define D3D11VA_CONTEXT(ctx)

Definition: dxva2_internal.h:101

H264SliceContext::ref_count

unsigned int ref_count[2]

num_ref_idx_l0/1_active_minus1 + 1

Definition: h264dec.h:267

AV_PICTURE_TYPE_SI

Switching Intra.

Definition: avutil.h:278

fill_slice_long

static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice, const DXVA_PicParams_H264 *pp, unsigned position, unsigned size)

Definition: dxva2_h264.c:216

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

PPS::scaling_matrix4

uint8_t scaling_matrix4[6][16]

Definition: h264_ps.h:124

PPS::deblocking_filter_parameters_present

int deblocking_filter_parameters_present

deblocking_filter_parameters_present_flag

Definition: h264_ps.h:120

ff_dxva2_common_frame_params

int ff_dxva2_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)

Definition: dxva2.c:586

H264ParamSets::pps

const PPS * pps

Definition: h264_ps.h:144

ff_dxva2_decode_uninit

int ff_dxva2_decode_uninit(AVCodecContext *avctx)

Definition: dxva2.c:724

uint8_t

Definition: audio_convert.c:194

H264SliceContext::slice_alpha_c0_offset

int slice_alpha_c0_offset

Definition: h264dec.h:194

SPS::bit_depth_chroma

int bit_depth_chroma

bit_depth_chroma_minus8 + 8

Definition: h264_ps.h:98

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

H264SliceContext::slice_type

int slice_type

Definition: h264dec.h:183

H264PredWeightTable::chroma_weight_flag

int chroma_weight_flag[2]

7.4.3.2 chroma_weight_lX_flag

Definition: h264_parse.h:36

is_slice_short

static int is_slice_short(const AVCodecContext *avctx, AVDXVAContext *ctx)

Definition: dxva2_h264.c:190

PPS::cabac

int cabac

entropy_coding_mode_flag

Definition: h264_ps.h:110

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:880

PICT_BOTTOM_FIELD

#define PICT_BOTTOM_FIELD

Definition: mpegutils.h:38

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:200

PPS::redundant_pic_cnt_present

int redundant_pic_cnt_present

redundant_pic_cnt_present_flag

Definition: h264_ps.h:122

ff_h264_d3d11va_hwaccel

const AVHWAccel ff_h264_d3d11va_hwaccel

size

ptrdiff_t size

Definition: opengl_enc.c:101

mpegutils.h

H264PredWeightTable::luma_weight

int luma_weight[48][2][2]

Definition: h264_parse.h:38

H264Ref::parent

H264Picture * parent

Definition: h264dec.h:174

dxva2_picture_context::slice

DXVA_SliceInfo slice[MAX_SLICES]

Definition: dxva2_mpeg2.c:34

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG

#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG

Work around for Direct3D11 and old UVD/UVD+ ATI video cards.

Definition: d3d11va.h:48

ff_h264_draw_horiz_band

void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)

Definition: h264dec.c:102

h264_ps.h

H.264 parameter set handling.

SPS::mb_aff

int mb_aff

mb_adaptive_frame_field_flag

Definition: h264_ps.h:62

H264PredWeightTable::chroma_log2_weight_denom

int chroma_log2_weight_denom

Definition: h264_parse.h:34

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

H264SliceContext::mb_x

int mb_x

Definition: h264dec.h:230

SPS::poc_type

int poc_type

pic_order_cnt_type

Definition: h264_ps.h:50

PPS::constrained_intra_pred

int constrained_intra_pred

constrained_intra_pred_flag

Definition: h264_ps.h:121

H264Picture::hwaccel_picture_private

void * hwaccel_picture_private

hardware accelerator private data

Definition: h264dec.h:142

const char * r

Definition: vf_curves.c:111

ff_zigzag_scan

const uint8_t ff_zigzag_scan[16+1]

Definition: mathtables.c:109

ff_dxva2_is_d3d11

int ff_dxva2_is_d3d11(const AVCodecContext *avctx)

Definition: dxva2.c:1045

H264SliceContext::deblocking_filter

int deblocking_filter

disable_deblocking_filter_idc with 1 <-> 0

Definition: h264dec.h:193

DXVA2_CONTEXT

#define DXVA2_CONTEXT(ctx)

Definition: dxva2_internal.h:102

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

PPS::weighted_pred

int weighted_pred

weighted_pred_flag

Definition: h264_ps.h:115

PICT_TOP_FIELD

#define PICT_TOP_FIELD

Definition: mpegutils.h:37

H264SliceContext::direct_spatial_mv_pred

int direct_spatial_mv_pred

Definition: h264dec.h:251

H264Picture::frame_num

int frame_num

frame_num (raw frame_num from slice header)

Definition: h264dec.h:149

MAX_SLICES

#define MAX_SLICES

Definition: dxva2_hevc.c:29

SPS::residual_color_transform_flag

int residual_color_transform_flag

residual_colour_transform_flag

Definition: h264_ps.h:99

ff_h264_get_slice_type

int ff_h264_get_slice_type(const H264SliceContext *sl)

Reconstruct bitstream slice_type.

Definition: h264_slice.c:2147

H264SliceContext::qscale

int qscale

Definition: h264dec.h:187

SPS::delta_pic_order_always_zero_flag

int delta_pic_order_always_zero_flag

Definition: h264_ps.h:52

fill_picture_parameters

static void fill_picture_parameters(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_PicParams_H264 *pp)

Definition: dxva2_h264.c:48

PPS::scaling_matrix8

uint8_t scaling_matrix8[6][64]

Definition: h264_ps.h:125

SPS::ref_frame_count

int ref_frame_count

num_ref_frames

Definition: h264_ps.h:56

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

AVHWAccel::name

const char * name

Name of the hardware accelerated codec.

Definition: avcodec.h:3582

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

H264Picture::reference

int reference

Definition: h264dec.h:160

decoder

static const chunk_decoder decoder[8]

Definition: dfa.c:330

H264SliceContext::redundant_pic_count

int redundant_pic_count

Definition: h264dec.h:244

FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO

#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO

Work around for Direct3D11 and old Intel GPUs with ClearVideo interface.

Definition: d3d11va.h:49

uint8_t w

Definition: llviddspenc.c:38

H264SliceContext::pwt

H264PredWeightTable pwt

Definition: h264dec.h:197

H264PredWeightTable::luma_log2_weight_denom

int luma_log2_weight_denom

Definition: h264_parse.h:33

AVDXVAContext

Definition: dxva2_internal.h:58

ctx

AVFormatContext * ctx

Definition: movenc.c:48

PPS::init_qp

int init_qp

pic_init_qp_minus26 + 26

Definition: h264_ps.h:117

ff_dxva2_decode_init

int ff_dxva2_decode_init(AVCodecContext *avctx)

Definition: dxva2.c:649

h264dec.h

H.264 / AVC / MPEG-4 part10 codec.

H264Context::slice_ctx

H264SliceContext * slice_ctx

Definition: h264dec.h:350

SPS::direct_8x8_inference_flag

int direct_8x8_inference_flag

Definition: h264_ps.h:63

H264Ref::reference

int reference

Definition: h264dec.h:170

dxva2_picture_context::bitstream_size

unsigned bitstream_size

Definition: dxva2_h264.c:38

FIELD_OR_MBAFF_PICTURE

#define FIELD_OR_MBAFF_PICTURE(h)

Definition: h264dec.h:91

AVCodecContext::height

int height

Definition: avcodec.h:1690

H264SliceContext::mb_y

int mb_y

Definition: h264dec.h:230

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

dxva2_picture_context::slice_long

DXVA_Slice_H264_Long slice_long[MAX_SLICES]

Definition: dxva2_h264.c:36

PPS::pic_order_present

int pic_order_present

pic_order_present_flag

Definition: h264_ps.h:111

dxva2_picture_context::slice_count

unsigned slice_count

Definition: dxva2_h264.c:34

fill_slice_short

static void fill_slice_short(DXVA_Slice_H264_Short *slice, unsigned position, unsigned size)

Definition: dxva2_h264.c:197

get_refpic_index

static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index)

Definition: dxva2_h264.c:206

H264Context::avctx

AVCodecContext * avctx

Definition: h264dec.h:339

FFDXVASharedContext

Definition: dxva2_internal.h:67

h264data.h

AVHWAccel

Definition: avcodec.h:3576

H264Context::short_ref

H264Picture * short_ref[32]

Definition: h264dec.h:463

ff_dxva2_get_surface_index

unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx, const AVDXVAContext *ctx, const AVFrame *frame)

Definition: dxva2.c:764

H264Picture::field_poc

int field_poc[2]

top/bottom POC

Definition: h264dec.h:147

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

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:791

type

GLint GLenum type

Definition: opengl_enc.c:105

dxva2_internal.h

pps

static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)

Definition: cbs_h264_syntax_template.c:356

index

int index

Definition: gxfenc.c:89

H264Context::cur_pic_ptr

H264Picture * cur_pic_ptr

Definition: h264dec.h:346

fill_scaling_lists

static void fill_scaling_lists(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)

Definition: dxva2_h264.c:164

ff_zigzag_direct

const uint8_t ff_zigzag_direct[64]

Definition: mathtables.c:98

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:214

H264ParamSets::sps

const SPS * sps

Definition: h264_ps.h:145

DECODER_BUFFER_DESC

void DECODER_BUFFER_DESC

Definition: dxva2_internal.h:56

SPS::log2_max_poc_lsb

int log2_max_poc_lsb

log2_max_pic_order_cnt_lsb_minus4

Definition: h264_ps.h:51

AV_PIX_FMT_DXVA2_VLD

HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...

Definition: pixfmt.h:133

dxva2_h264_decode_slice

static int dxva2_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)

Definition: dxva2_h264.c:465

PPS::transform_8x8_mode

int transform_8x8_mode

transform_8x8_mode_flag

Definition: h264_ps.h:123

H264SliceContext::list_count

unsigned int list_count

Definition: h264dec.h:268

FAILED

#define FAILED(hr)

Definition: windows2linux.h:48

ff_h264_dxva2_hwaccel

const AVHWAccel ff_h264_dxva2_hwaccel

AV_PIX_FMT_D3D11

Hardware surfaces for Direct3D11.

Definition: pixfmt.h:309

commit_bitstream_and_slice_buffer

static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *sc)

Definition: dxva2_h264.c:297

H264Picture

Definition: h264dec.h:128

dxva2_picture_context::bitstream

const uint8_t * bitstream

Definition: dxva2_h264.c:37

PPS::init_qs

int init_qs

pic_init_qs_minus26 + 26

Definition: h264_ps.h:118

H264Picture::pic_id

int pic_id

pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...

Definition: h264dec.h:152

ff_h264_d3d11va2_hwaccel

const AVHWAccel ff_h264_d3d11va2_hwaccel

if(ret< 0)

Definition: vf_mcdeint.c:279

SPS::log2_max_frame_num

int log2_max_frame_num

log2_max_frame_num_minus4 + 4

Definition: h264_ps.h:49

H264Context::ps

H264ParamSets ps

Definition: h264dec.h:456

AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:276

SPS::bit_depth_luma

int bit_depth_luma

bit_depth_luma_minus8 + 8

Definition: h264_ps.h:97

H264POCContext::frame_num

int frame_num

Definition: h264_parse.h:48

dxva2_h264_start_frame

static int dxva2_h264_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)

Definition: dxva2_h264.c:441

dxva2_h264_end_frame

static int dxva2_h264_end_frame(AVCodecContext *avctx)

Definition: dxva2_h264.c:497

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:39

H264Context::mb_width

int mb_width

Definition: h264dec.h:435

H264Context::current_slice

int current_slice

current slice number, used to initialize slice_num of each thread/context

Definition: h264dec.h:488

DXVA_CONTEXT

#define DXVA_CONTEXT(avctx)

Definition: dxva2_internal.h:99

PPS::slice_group_count

int slice_group_count

num_slice_groups_minus1 + 1

Definition: h264_ps.h:112

H264SliceContext::ref_list

H264Ref ref_list[2][48]

0..15: frame refs, 16..47: mbaff field refs.

Definition: h264dec.h:269

H264SliceContext::slice_type_fixed

int slice_type_fixed

Definition: h264dec.h:185

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

start_code

static const uint8_t start_code[]

Definition: videotoolboxenc.c:168

AV_PIX_FMT_D3D11VA_VLD

HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...

Definition: pixfmt.h:225

H264SliceContext::slice_beta_offset

int slice_beta_offset

Definition: h264dec.h:195

SPS::level_idc

int level_idc

Definition: h264_ps.h:46

dxva2_picture_context::slice_short

DXVA_Slice_H264_Short slice_short[MAX_SLICES]

Definition: dxva2_h264.c:35

H264Context::nal_ref_idc

int nal_ref_idc

Definition: h264dec.h:442

H264SliceContext::gb

GetBitContext gb

Definition: h264dec.h:179

H264SliceContext::cabac_init_idc

int cabac_init_idc

Definition: h264dec.h:320

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

fill_picture_entry

static void fill_picture_entry(DXVA_PicEntry_H264 *pic, unsigned index, unsigned flag)

Definition: dxva2_h264.c:41

buffer

GLuint buffer

Definition: opengl_enc.c:102

av_unused

#define av_unused

Definition: attributes.h:125

dxva2_picture_context

Definition: dxva2_h264.c:31

H264Context::short_ref_count

int short_ref_count

number of actual short term references

Definition: h264dec.h:479

PPS::mb_slice_group_map_type

int mb_slice_group_map_type

Definition: h264_ps.h:113

dxva2_picture_context::qm

DXVA_Qmatrix_H264 qm

Definition: dxva2_h264.c:33

Generated on Sun May 13 2018 02:03:45 for FFmpeg by doxygen 1.8.6