FFmpeg: libavcodec/vdpau.c Source File

FFmpeg

[フレーム]

libavcodec

vdpau.c

Go to the documentation of this file.

1 /*

2 * Video Decode and Presentation API for UNIX (VDPAU) is used for

3 * HW decode acceleration for MPEG-1/2, MPEG-4 ASP, H.264 and VC-1.

4 *

6 *

7 * This file is part of FFmpeg.

8 *

9 * FFmpeg is free software; you can redistribute it and/or

10 * modify it under the terms of the GNU Lesser General Public

11 * License as published by the Free Software Foundation; either

12 * version 2.1 of the License, or (at your option) any later version.

13 *

14 * FFmpeg is distributed in the hope that it will be useful,

15 * but WITHOUT ANY WARRANTY; without even the implied warranty of

16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

17 * Lesser General Public License for more details.

18 *

19 * You should have received a copy of the GNU Lesser General Public

20 * License along with FFmpeg; if not, write to the Free Software

21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

22 */

24 #include <limits.h>

25 #include "libavutil/avassert.h"

26 #include "avcodec.h"

27 #include "internal.h"

28 #include "h264.h"

29 #include "vc1.h"

31 #undef NDEBUG

32 #include <assert.h>

34 #include "vdpau.h"

35 #include "vdpau_internal.h"

37 /**

38 * @addtogroup VDPAU_Decoding

39 *

40 * @{

41 */

43 static int vdpau_error(VdpStatus status)

44 {

45 switch (status) {

46 case VDP_STATUS_OK:

47 return 0;

48 case VDP_STATUS_NO_IMPLEMENTATION:

49 return AVERROR(ENOSYS);

50 case VDP_STATUS_DISPLAY_PREEMPTED:

51 return AVERROR(EIO);

52 case VDP_STATUS_INVALID_HANDLE:

53 return AVERROR(EBADF);

54 case VDP_STATUS_INVALID_POINTER:

55 return AVERROR(EFAULT);

56 case VDP_STATUS_RESOURCES:

57 return AVERROR(ENOBUFS);

58 case VDP_STATUS_HANDLE_DEVICE_MISMATCH:

59 return AVERROR(EXDEV);

60 case VDP_STATUS_ERROR:

61 return AVERROR(EIO);

62 default:

63 return AVERROR(EINVAL);

64 }

65 }

67 AVVDPAUContext *av_alloc_vdpaucontext(void)

68 {

69 return av_vdpau_alloc_context();

70 }

72 MAKE_ACCESSORS(AVVDPAUContext, vdpau_hwaccel, AVVDPAU_Render2, render2)

74 int av_vdpau_get_surface_parameters(AVCodecContext *avctx,

75 VdpChromaType *type,

76 uint32_t *width, uint32_t *height)

77 {

78 VdpChromaType t;

79 uint32_t w = avctx->coded_width;

80 uint32_t h = avctx->coded_height;

82 /* See <vdpau/vdpau.h> for per-type alignment constraints. */

83 switch (avctx->sw_pix_fmt) {

84 case AV_PIX_FMT_YUV420P:

85 case AV_PIX_FMT_YUVJ420P:

86 t = VDP_CHROMA_TYPE_420;

87 w = (w + 1) & ~1;

88 h = (h + 3) & ~3;

89 break;

90 case AV_PIX_FMT_YUV422P:

91 case AV_PIX_FMT_YUVJ422P:

92 t = VDP_CHROMA_TYPE_422;

93 w = (w + 1) & ~1;

94 h = (h + 1) & ~1;

95 break;

96 case AV_PIX_FMT_YUV444P:

97 case AV_PIX_FMT_YUVJ444P:

98 t = VDP_CHROMA_TYPE_444;

99 h = (h + 1) & ~1;

100 break;

101 default:

102 return AVERROR(ENOSYS);

103 }

104

105 if (type)

106 *type = t;

107 if (width)

108 *width = w;

109 if (height)

110 *height = h;

111 return 0;

112 }

113

114 int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,

115 int level)

116 {

117 VDPAUHWContext *hwctx = avctx->hwaccel_context;

118 VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;

119 VdpVideoSurfaceQueryCapabilities *surface_query_caps;

120 VdpDecoderQueryCapabilities *decoder_query_caps;

121 VdpDecoderCreate *create;

122 void *func;

123 VdpStatus status;

124 VdpBool supported;

125 uint32_t max_level, max_mb, max_width, max_height;

126 VdpChromaType type;

127 uint32_t width;

128 uint32_t height;

129

130 vdctx->width = UINT32_MAX;

131 vdctx->height = UINT32_MAX;

132

133 if (!hwctx) {

134 vdctx->device = VDP_INVALID_HANDLE;

135 av_log(avctx, AV_LOG_WARNING, "hwaccel_context has not been setup by the user application, cannot initialize\n");

136 return 0;

137 }

138

139 if (hwctx->context.decoder != VDP_INVALID_HANDLE) {

140 vdctx->decoder = hwctx->context.decoder;

141 vdctx->render = hwctx->context.render;

142 vdctx->device = VDP_INVALID_HANDLE;

143 return 0; /* Decoder created by user */

144 }

145 hwctx->reset = 0;

146

147 vdctx->device = hwctx->device;

148 vdctx->get_proc_address = hwctx->get_proc_address;

149

150 if (hwctx->flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)

151 level = 0;

152 else if (level < 0)

153 return AVERROR(ENOTSUP);

154

155 if (av_vdpau_get_surface_parameters(avctx, &type, &width, &height))

156 return AVERROR(ENOSYS);

157

158 if (!(hwctx->flags & AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH) &&

159 type != VDP_CHROMA_TYPE_420)

160 return AVERROR(ENOSYS);

161

162 status = vdctx->get_proc_address(vdctx->device,

163 VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES,

164 &func);

165 if (status != VDP_STATUS_OK)

166 return vdpau_error(status);

167 else

168 surface_query_caps = func;

169

170 status = surface_query_caps(vdctx->device, type, &supported,

171 &max_width, &max_height);

172 if (status != VDP_STATUS_OK)

173 return vdpau_error(status);

174 if (supported != VDP_TRUE ||

175 max_width < width || max_height < height)

176 return AVERROR(ENOTSUP);

177

178 status = vdctx->get_proc_address(vdctx->device,

179 VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES,

180 &func);

181 if (status != VDP_STATUS_OK)

182 return vdpau_error(status);

183 else

184 decoder_query_caps = func;

185

186 status = decoder_query_caps(vdctx->device, profile, &supported, &max_level,

187 &max_mb, &max_width, &max_height);

188 #ifdef VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE

189 if (status != VDP_STATUS_OK && profile == VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE) {

190 /* Run-time backward compatibility for libvdpau 0.8 and earlier */

191 profile = VDP_DECODER_PROFILE_H264_MAIN;

192 status = decoder_query_caps(vdctx->device, profile, &supported,

193 &max_level, &max_mb,

194 &max_width, &max_height);

195 }

196 #endif

197 if (status != VDP_STATUS_OK)

198 return vdpau_error(status);

199

200 if (supported != VDP_TRUE || max_level < level ||

201 max_width < width || max_height < height)

202 return AVERROR(ENOTSUP);

203

204 status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,

205 &func);

206 if (status != VDP_STATUS_OK)

207 return vdpau_error(status);

208 else

209 create = func;

210

211 status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,

212 &func);

213 if (status != VDP_STATUS_OK)

214 return vdpau_error(status);

215 else

216 vdctx->render = func;

217

218 status = create(vdctx->device, profile, width, height, avctx->refs,

219 &vdctx->decoder);

220 if (status == VDP_STATUS_OK) {

221 vdctx->width = avctx->coded_width;

222 vdctx->height = avctx->coded_height;

223 }

224

225 return vdpau_error(status);

226 }

227

228 int ff_vdpau_common_uninit(AVCodecContext *avctx)

229 {

230 VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;

231 VdpDecoderDestroy *destroy;

232 void *func;

233 VdpStatus status;

234

235 if (vdctx->device == VDP_INVALID_HANDLE)

236 return 0; /* Decoder created and destroyed by user */

237 if (vdctx->width == UINT32_MAX && vdctx->height == UINT32_MAX)

238 return 0;

239

240 status = vdctx->get_proc_address(vdctx->device,

241 VDP_FUNC_ID_DECODER_DESTROY, &func);

242 if (status != VDP_STATUS_OK)

243 return vdpau_error(status);

244 else

245 destroy = func;

246

247 status = destroy(vdctx->decoder);

248 return vdpau_error(status);

249 }

250

251 static int ff_vdpau_common_reinit(AVCodecContext *avctx)

252 {

253 VDPAUHWContext *hwctx = avctx->hwaccel_context;

254 VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;

255

256 if (vdctx->device == VDP_INVALID_HANDLE)

257 return 0; /* Decoder created by user */

258 if (avctx->coded_width == vdctx->width &&

259 avctx->coded_height == vdctx->height && !hwctx->reset)

260 return 0;

261

262 avctx->hwaccel->uninit(avctx);

263 return avctx->hwaccel->init(avctx);

264 }

265

266 int ff_vdpau_common_start_frame(struct vdpau_picture_context *pic_ctx,

267 av_unused const uint8_t *buffer,

268 av_unused uint32_t size)

269 {

270 pic_ctx->bitstream_buffers_allocated = 0;

271 pic_ctx->bitstream_buffers_used = 0;

272 pic_ctx->bitstream_buffers = NULL;

273 return 0;

274 }

275

276 int ff_vdpau_common_end_frame(AVCodecContext *avctx, AVFrame *frame,

277 struct vdpau_picture_context *pic_ctx)

278 {

279 VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;

280 AVVDPAUContext *hwctx = avctx->hwaccel_context;

281 VdpVideoSurface surf = ff_vdpau_get_surface_id(frame);

282 VdpStatus status;

283 int val;

284

285 val = ff_vdpau_common_reinit(avctx);

286 if (val < 0)

287 return val;

288

289 #if FF_API_BUFS_VDPAU

290 FF_DISABLE_DEPRECATION_WARNINGS

291 av_assert0(sizeof(hwctx->info) <= sizeof(pic_ctx->info));

292 memcpy(&hwctx->info, &pic_ctx->info, sizeof(hwctx->info));

293 hwctx->bitstream_buffers = pic_ctx->bitstream_buffers;

294 hwctx->bitstream_buffers_used = pic_ctx->bitstream_buffers_used;

295 hwctx->bitstream_buffers_allocated = pic_ctx->bitstream_buffers_allocated;

296 FF_ENABLE_DEPRECATION_WARNINGS

297 #endif

298

299 if (!hwctx->render && hwctx->render2) {

300 status = hwctx->render2(avctx, frame, (void *)&pic_ctx->info,

301 pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers);

302 } else

303 status = vdctx->render(vdctx->decoder, surf, (void *)&pic_ctx->info,

304 pic_ctx->bitstream_buffers_used,

305 pic_ctx->bitstream_buffers);

306

307 av_freep(&pic_ctx->bitstream_buffers);

308

309 #if FF_API_BUFS_VDPAU

310 FF_DISABLE_DEPRECATION_WARNINGS

311 hwctx->bitstream_buffers = NULL;

312 hwctx->bitstream_buffers_used = 0;

313 hwctx->bitstream_buffers_allocated = 0;

314 FF_ENABLE_DEPRECATION_WARNINGS

315 #endif

316

317 return vdpau_error(status);

318 }

319

320 #if CONFIG_H263_VDPAU_HWACCEL || CONFIG_MPEG1_VDPAU_HWACCEL || \

321 CONFIG_MPEG2_VDPAU_HWACCEL || CONFIG_MPEG4_VDPAU_HWACCEL || \

322 CONFIG_VC1_VDPAU_HWACCEL || CONFIG_WMV3_VDPAU_HWACCEL

323 int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx)

324 {

325 MpegEncContext *s = avctx->priv_data;

326 Picture *pic = s->current_picture_ptr;

327 struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;

328 int val;

329

330 val = ff_vdpau_common_end_frame(avctx, pic->f, pic_ctx);

331 if (val < 0)

332 return val;

333

334 ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);

335 return 0;

336 }

337 #endif

338

339 int ff_vdpau_add_buffer(struct vdpau_picture_context *pic_ctx,

340 const uint8_t *buf, uint32_t size)

341 {

342 VdpBitstreamBuffer *buffers = pic_ctx->bitstream_buffers;

343

344 buffers = av_fast_realloc(buffers, &pic_ctx->bitstream_buffers_allocated,

345 (pic_ctx->bitstream_buffers_used + 1) * sizeof(*buffers));

346 if (!buffers)

347 return AVERROR(ENOMEM);

348

349 pic_ctx->bitstream_buffers = buffers;

350 buffers += pic_ctx->bitstream_buffers_used++;

351

352 buffers->struct_version = VDP_BITSTREAM_BUFFER_VERSION;

353 buffers->bitstream = buf;

354 buffers->bitstream_bytes = size;

355 return 0;

356 }

357

358 /* Obsolete non-hwaccel VDPAU support below... */

359

360 void ff_vdpau_h264_set_reference_frames(H264Context *h)

361 {

362 struct vdpau_render_state *render, *render_ref;

363 VdpReferenceFrameH264 *rf, *rf2;

364 H264Picture *pic;

365 int i, list, pic_frame_idx;

366

367 render = (struct vdpau_render_state *)h->cur_pic_ptr->f.data[0];

368 assert(render);

369

370 rf = &render->info.h264.referenceFrames[0];

371 #define H264_RF_COUNT FF_ARRAY_ELEMS(render->info.h264.referenceFrames)

372

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

374 H264Picture **lp = list ? h->long_ref : h->short_ref;

375 int ls = list ? 16 : h->short_ref_count;

376

377 for (i = 0; i < ls; ++i) {

378 pic = lp[i];

379 if (!pic || !pic->reference)

380 continue;

381 pic_frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num;

382

383 render_ref = (struct vdpau_render_state *)pic->f.data[0];

384 assert(render_ref);

385

386 rf2 = &render->info.h264.referenceFrames[0];

387 while (rf2 != rf) {

388 if (

389 (rf2->surface == render_ref->surface)

390 && (rf2->is_long_term == pic->long_ref)

391 && (rf2->frame_idx == pic_frame_idx)

392 )

393 break;

394 ++rf2;

395 }

396 if (rf2 != rf) {

397 rf2->top_is_reference |= (pic->reference & PICT_TOP_FIELD) ? VDP_TRUE : VDP_FALSE;

398 rf2->bottom_is_reference |= (pic->reference & PICT_BOTTOM_FIELD) ? VDP_TRUE : VDP_FALSE;

399 continue;

400 }

401

402 if (rf >= &render->info.h264.referenceFrames[H264_RF_COUNT])

403 continue;

404

405 rf->surface = render_ref->surface;

406 rf->is_long_term = pic->long_ref;

407 rf->top_is_reference = (pic->reference & PICT_TOP_FIELD) ? VDP_TRUE : VDP_FALSE;

408 rf->bottom_is_reference = (pic->reference & PICT_BOTTOM_FIELD) ? VDP_TRUE : VDP_FALSE;

409 rf->field_order_cnt[0] = pic->field_poc[0];

410 rf->field_order_cnt[1] = pic->field_poc[1];

411 rf->frame_idx = pic_frame_idx;

412

413 ++rf;

414 }

415 }

416

417 for (; rf < &render->info.h264.referenceFrames[H264_RF_COUNT]; ++rf) {

418 rf->surface = VDP_INVALID_HANDLE;

419 rf->is_long_term = 0;

420 rf->top_is_reference = 0;

421 rf->bottom_is_reference = 0;

422 rf->field_order_cnt[0] = 0;

423 rf->field_order_cnt[1] = 0;

424 rf->frame_idx = 0;

425 }

426 }

427

428 void ff_vdpau_add_data_chunk(uint8_t *data, const uint8_t *buf, int buf_size)

429 {

430 struct vdpau_render_state *render = (struct vdpau_render_state*)data;

431 assert(render);

432

433 render->bitstream_buffers= av_fast_realloc(

434 render->bitstream_buffers,

435 &render->bitstream_buffers_allocated,

436 sizeof(*render->bitstream_buffers)*(render->bitstream_buffers_used + 1)

437 );

438

439 render->bitstream_buffers[render->bitstream_buffers_used].struct_version = VDP_BITSTREAM_BUFFER_VERSION;

440 render->bitstream_buffers[render->bitstream_buffers_used].bitstream = buf;

441 render->bitstream_buffers[render->bitstream_buffers_used].bitstream_bytes = buf_size;

442 render->bitstream_buffers_used++;

443 }

444

445 #if CONFIG_H264_VDPAU_DECODER

446 void ff_vdpau_h264_picture_start(H264Context *h)

447 {

448 struct vdpau_render_state *render;

449 int i;

450

451 render = (struct vdpau_render_state *)h->cur_pic_ptr->f.data[0];

452 assert(render);

453

454 for (i = 0; i < 2; ++i) {

455 int foc = h->cur_pic_ptr->field_poc[i];

456 if (foc == INT_MAX)

457 foc = 0;

458 render->info.h264.field_order_cnt[i] = foc;

459 }

460

461 render->info.h264.frame_num = h->frame_num;

462 }

463

464 void ff_vdpau_h264_picture_complete(H264Context *h)

465 {

466 struct vdpau_render_state *render;

467

468 render = (struct vdpau_render_state *)h->cur_pic_ptr->f.data[0];

469 assert(render);

470

471 render->info.h264.slice_count = h->slice_num;

472 if (render->info.h264.slice_count < 1)

473 return;

474

475 render->info.h264.is_reference = (h->cur_pic_ptr->reference & 3) ? VDP_TRUE : VDP_FALSE;

476 render->info.h264.field_pic_flag = h->picture_structure != PICT_FRAME;

477 render->info.h264.bottom_field_flag = h->picture_structure == PICT_BOTTOM_FIELD;

478 render->info.h264.num_ref_frames = h->sps.ref_frame_count;

479 render->info.h264.mb_adaptive_frame_field_flag = h->sps.mb_aff && !render->info.h264.field_pic_flag;

480 render->info.h264.constrained_intra_pred_flag = h->pps.constrained_intra_pred;

481 render->info.h264.weighted_pred_flag = h->pps.weighted_pred;

482 render->info.h264.weighted_bipred_idc = h->pps.weighted_bipred_idc;

483 render->info.h264.frame_mbs_only_flag = h->sps.frame_mbs_only_flag;

484 render->info.h264.transform_8x8_mode_flag = h->pps.transform_8x8_mode;

485 render->info.h264.chroma_qp_index_offset = h->pps.chroma_qp_index_offset[0];

486 render->info.h264.second_chroma_qp_index_offset = h->pps.chroma_qp_index_offset[1];

487 render->info.h264.pic_init_qp_minus26 = h->pps.init_qp - 26;

488 render->info.h264.num_ref_idx_l0_active_minus1 = h->pps.ref_count[0] - 1;

489 render->info.h264.num_ref_idx_l1_active_minus1 = h->pps.ref_count[1] - 1;

490 render->info.h264.log2_max_frame_num_minus4 = h->sps.log2_max_frame_num - 4;

491 render->info.h264.pic_order_cnt_type = h->sps.poc_type;

492 render->info.h264.log2_max_pic_order_cnt_lsb_minus4 = h->sps.poc_type ? 0 : h->sps.log2_max_poc_lsb - 4;

493 render->info.h264.delta_pic_order_always_zero_flag = h->sps.delta_pic_order_always_zero_flag;

494 render->info.h264.direct_8x8_inference_flag = h->sps.direct_8x8_inference_flag;

495 render->info.h264.entropy_coding_mode_flag = h->pps.cabac;

496 render->info.h264.pic_order_present_flag = h->pps.pic_order_present;

497 render->info.h264.deblocking_filter_control_present_flag = h->pps.deblocking_filter_parameters_present;

498 render->info.h264.redundant_pic_cnt_present_flag = h->pps.redundant_pic_cnt_present;

499 memcpy(render->info.h264.scaling_lists_4x4, h->pps.scaling_matrix4, sizeof(render->info.h264.scaling_lists_4x4));

500 memcpy(render->info.h264.scaling_lists_8x8[0], h->pps.scaling_matrix8[0], sizeof(render->info.h264.scaling_lists_8x8[0]));

501 memcpy(render->info.h264.scaling_lists_8x8[1], h->pps.scaling_matrix8[3], sizeof(render->info.h264.scaling_lists_8x8[0]));

502

503 ff_h264_draw_horiz_band(h, 0, h->avctx->height);

504 render->bitstream_buffers_used = 0;

505 }

506 #endif /* CONFIG_H264_VDPAU_DECODER */

507

508 #if CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER

509 void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf,

510 int buf_size, int slice_count)

511 {

512 struct vdpau_render_state *render, *last, *next;

513 int i;

514

515 if (!s->current_picture_ptr) return;

516

517 render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0];

518 assert(render);

519

520 /* fill VdpPictureInfoMPEG1Or2 struct */

521 render->info.mpeg.picture_structure = s->picture_structure;

522 render->info.mpeg.picture_coding_type = s->pict_type;

523 render->info.mpeg.intra_dc_precision = s->intra_dc_precision;

524 render->info.mpeg.frame_pred_frame_dct = s->frame_pred_frame_dct;

525 render->info.mpeg.concealment_motion_vectors = s->concealment_motion_vectors;

526 render->info.mpeg.intra_vlc_format = s->intra_vlc_format;

527 render->info.mpeg.alternate_scan = s->alternate_scan;

528 render->info.mpeg.q_scale_type = s->q_scale_type;

529 render->info.mpeg.top_field_first = s->top_field_first;

530 render->info.mpeg.full_pel_forward_vector = s->full_pel[0]; // MPEG-1 only. Set 0 for MPEG-2

531 render->info.mpeg.full_pel_backward_vector = s->full_pel[1]; // MPEG-1 only. Set 0 for MPEG-2

532 render->info.mpeg.f_code[0][0] = s->mpeg_f_code[0][0]; // For MPEG-1 fill both horiz. & vert.

533 render->info.mpeg.f_code[0][1] = s->mpeg_f_code[0][1];

534 render->info.mpeg.f_code[1][0] = s->mpeg_f_code[1][0];

535 render->info.mpeg.f_code[1][1] = s->mpeg_f_code[1][1];

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

537 render->info.mpeg.intra_quantizer_matrix[i] = s->intra_matrix[i];

538 render->info.mpeg.non_intra_quantizer_matrix[i] = s->inter_matrix[i];

539 }

540

541 render->info.mpeg.forward_reference = VDP_INVALID_HANDLE;

542 render->info.mpeg.backward_reference = VDP_INVALID_HANDLE;

543

544 switch(s->pict_type){

545 case AV_PICTURE_TYPE_B:

546 next = (struct vdpau_render_state *)s->next_picture.f->data[0];

547 assert(next);

548 render->info.mpeg.backward_reference = next->surface;

549 // no return here, going to set forward prediction

550 case AV_PICTURE_TYPE_P:

551 last = (struct vdpau_render_state *)s->last_picture.f->data[0];

552 if (!last) // FIXME: Does this test make sense?

553 last = render; // predict second field from the first

554 render->info.mpeg.forward_reference = last->surface;

555 }

556

557 ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);

558

559 render->info.mpeg.slice_count = slice_count;

560

561 if (slice_count)

562 ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);

563 render->bitstream_buffers_used = 0;

564 }

565 #endif /* CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER */

566

567 #if CONFIG_VC1_VDPAU_DECODER

568 void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf,

569 int buf_size)

570 {

571 VC1Context *v = s->avctx->priv_data;

572 struct vdpau_render_state *render, *last, *next;

573

574 render = (struct vdpau_render_state *)s->current_picture.f->data[0];

575 assert(render);

576

577 /* fill LvPictureInfoVC1 struct */

578 render->info.vc1.frame_coding_mode = v->fcm ? v->fcm + 1 : 0;

579 render->info.vc1.postprocflag = v->postprocflag;

580 render->info.vc1.pulldown = v->broadcast;

581 render->info.vc1.interlace = v->interlace;

582 render->info.vc1.tfcntrflag = v->tfcntrflag;

583 render->info.vc1.finterpflag = v->finterpflag;

584 render->info.vc1.psf = v->psf;

585 render->info.vc1.dquant = v->dquant;

586 render->info.vc1.panscan_flag = v->panscanflag;

587 render->info.vc1.refdist_flag = v->refdist_flag;

588 render->info.vc1.quantizer = v->quantizer_mode;

589 render->info.vc1.extended_mv = v->extended_mv;

590 render->info.vc1.extended_dmv = v->extended_dmv;

591 render->info.vc1.overlap = v->overlap;

592 render->info.vc1.vstransform = v->vstransform;

593 render->info.vc1.loopfilter = v->s.loop_filter;

594 render->info.vc1.fastuvmc = v->fastuvmc;

595 render->info.vc1.range_mapy_flag = v->range_mapy_flag;

596 render->info.vc1.range_mapy = v->range_mapy;

597 render->info.vc1.range_mapuv_flag = v->range_mapuv_flag;

598 render->info.vc1.range_mapuv = v->range_mapuv;

599 /* Specific to simple/main profile only */

600 render->info.vc1.multires = v->multires;

601 render->info.vc1.syncmarker = v->resync_marker;

602 render->info.vc1.rangered = v->rangered | (v->rangeredfrm << 1);

603 render->info.vc1.maxbframes = v->s.max_b_frames;

604

605 render->info.vc1.deblockEnable = v->postprocflag & 1;

606 render->info.vc1.pquant = v->pq;

607

608 render->info.vc1.forward_reference = VDP_INVALID_HANDLE;

609 render->info.vc1.backward_reference = VDP_INVALID_HANDLE;

610

611 if (v->bi_type)

612 render->info.vc1.picture_type = 4;

613 else

614 render->info.vc1.picture_type = s->pict_type - 1 + s->pict_type / 3;

615

616 switch(s->pict_type){

617 case AV_PICTURE_TYPE_B:

618 next = (struct vdpau_render_state *)s->next_picture.f->data[0];

619 assert(next);

620 render->info.vc1.backward_reference = next->surface;

621 // no break here, going to set forward prediction

622 case AV_PICTURE_TYPE_P:

623 last = (struct vdpau_render_state *)s->last_picture.f->data[0];

624 if (!last) // FIXME: Does this test make sense?

625 last = render; // predict second field from the first

626 render->info.vc1.forward_reference = last->surface;

627 }

628

629 ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);

630

631 render->info.vc1.slice_count = 1;

632

633 ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);

634 render->bitstream_buffers_used = 0;

635 }

636 #endif /* (CONFIG_VC1_VDPAU_DECODER */

637

638 #if CONFIG_MPEG4_VDPAU_DECODER

639 void ff_vdpau_mpeg4_decode_picture(Mpeg4DecContext *ctx, const uint8_t *buf,

640 int buf_size)

641 {

642 MpegEncContext *s = &ctx->m;

643 struct vdpau_render_state *render, *last, *next;

644 int i;

645

646 if (!s->current_picture_ptr) return;

647

648 render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0];

649 assert(render);

650

651 /* fill VdpPictureInfoMPEG4Part2 struct */

652 render->info.mpeg4.trd[0] = s->pp_time;

653 render->info.mpeg4.trb[0] = s->pb_time;

654 render->info.mpeg4.trd[1] = s->pp_field_time >> 1;

655 render->info.mpeg4.trb[1] = s->pb_field_time >> 1;

656 render->info.mpeg4.vop_time_increment_resolution = s->avctx->time_base.den;

657 render->info.mpeg4.vop_coding_type = 0;

658 render->info.mpeg4.vop_fcode_forward = s->f_code;

659 render->info.mpeg4.vop_fcode_backward = s->b_code;

660 render->info.mpeg4.resync_marker_disable = !ctx->resync_marker;

661 render->info.mpeg4.interlaced = !s->progressive_sequence;

662 render->info.mpeg4.quant_type = s->mpeg_quant;

663 render->info.mpeg4.quarter_sample = s->quarter_sample;

664 render->info.mpeg4.short_video_header = s->avctx->codec->id == AV_CODEC_ID_H263;

665 render->info.mpeg4.rounding_control = s->no_rounding;

666 render->info.mpeg4.alternate_vertical_scan_flag = s->alternate_scan;

667 render->info.mpeg4.top_field_first = s->top_field_first;

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

669 render->info.mpeg4.intra_quantizer_matrix[i] = s->intra_matrix[i];

670 render->info.mpeg4.non_intra_quantizer_matrix[i] = s->inter_matrix[i];

671 }

672 render->info.mpeg4.forward_reference = VDP_INVALID_HANDLE;

673 render->info.mpeg4.backward_reference = VDP_INVALID_HANDLE;

674

675 switch (s->pict_type) {

676 case AV_PICTURE_TYPE_B:

677 next = (struct vdpau_render_state *)s->next_picture.f->data[0];

678 assert(next);

679 render->info.mpeg4.backward_reference = next->surface;

680 render->info.mpeg4.vop_coding_type = 2;

681 // no break here, going to set forward prediction

682 case AV_PICTURE_TYPE_P:

683 last = (struct vdpau_render_state *)s->last_picture.f->data[0];

684 assert(last);

685 render->info.mpeg4.forward_reference = last->surface;

686 }

687

688 ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size);

689

690 ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);

691 render->bitstream_buffers_used = 0;

692 }

693 #endif /* CONFIG_MPEG4_VDPAU_DECODER */

694

695 int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile)

696 {

697 #define PROFILE(prof) \

698 do { \

699 *profile = VDP_DECODER_PROFILE_##prof; \

700 return 0; \

701 } while (0)

702

703 switch (avctx->codec_id) {

704 case AV_CODEC_ID_MPEG1VIDEO: PROFILE(MPEG1);

705 case AV_CODEC_ID_MPEG2VIDEO:

706 switch (avctx->profile) {

707 case FF_PROFILE_MPEG2_MAIN: PROFILE(MPEG2_MAIN);

708 case FF_PROFILE_MPEG2_SIMPLE: PROFILE(MPEG2_SIMPLE);

709 default: return AVERROR(EINVAL);

710 }

711 case AV_CODEC_ID_H263: PROFILE(MPEG4_PART2_ASP);

712 case AV_CODEC_ID_MPEG4:

713 switch (avctx->profile) {

714 case FF_PROFILE_MPEG4_SIMPLE: PROFILE(MPEG4_PART2_SP);

715 case FF_PROFILE_MPEG4_ADVANCED_SIMPLE: PROFILE(MPEG4_PART2_ASP);

716 default: return AVERROR(EINVAL);

717 }

718 case AV_CODEC_ID_H264:

719 switch (avctx->profile & ~FF_PROFILE_H264_INTRA) {

720 case FF_PROFILE_H264_BASELINE: PROFILE(H264_BASELINE);

721 case FF_PROFILE_H264_CONSTRAINED_BASELINE:

722 case FF_PROFILE_H264_MAIN: PROFILE(H264_MAIN);

723 case FF_PROFILE_H264_HIGH: PROFILE(H264_HIGH);

724 #ifdef VDP_DECODER_PROFILE_H264_EXTENDED

725 case FF_PROFILE_H264_EXTENDED: PROFILE(H264_EXTENDED);

726 #endif

727 default: return AVERROR(EINVAL);

728 }

729 case AV_CODEC_ID_WMV3:

730 case AV_CODEC_ID_VC1:

731 switch (avctx->profile) {

732 case FF_PROFILE_VC1_SIMPLE: PROFILE(VC1_SIMPLE);

733 case FF_PROFILE_VC1_MAIN: PROFILE(VC1_MAIN);

734 case FF_PROFILE_VC1_ADVANCED: PROFILE(VC1_ADVANCED);

735 default: return AVERROR(EINVAL);

736 }

737 }

738 return AVERROR(EINVAL);

739 #undef PROFILE

740 }

741

742 AVVDPAUContext *av_vdpau_alloc_context(void)

743 {

744 return av_mallocz(sizeof(AVVDPAUContext));

745 }

746

747 int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device,

748 VdpGetProcAddress *get_proc, unsigned flags)

749 {

750 VDPAUHWContext *hwctx;

751

752 if (flags & ~(AV_HWACCEL_FLAG_IGNORE_LEVEL|AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH))

753 return AVERROR(EINVAL);

754

755 if (av_reallocp(&avctx->hwaccel_context, sizeof(*hwctx)))

756 return AVERROR(ENOMEM);

757

758 hwctx = avctx->hwaccel_context;

759

760 memset(hwctx, 0, sizeof(*hwctx));

761 hwctx->context.decoder = VDP_INVALID_HANDLE;

762 hwctx->device = device;

763 hwctx->get_proc_address = get_proc;

764 hwctx->flags = flags;

765 hwctx->reset = 1;

766 return 0;

767 }

768

769 /* @}*/

Generated on Sun Mar 8 2015 02:35:02 for FFmpeg by doxygen 1.8.2