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.
5 * Copyright (c) 2008 NVIDIA
7 * This file is part of FFmpeg.
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.
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.
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
33 #include "vdpau_internal.h"
36 * @addtogroup VDPAU_Decoding
41 AVVDPAUContext
*av_alloc_vdpaucontext(void)
43 return av_vdpau_alloc_context();
46 MAKE_ACCESSORS(AVVDPAUContext
, vdpau_hwaccel
, AVVDPAU_Render2
, render2
)
48 int ff_vdpau_common_start_frame(struct vdpau_picture_context
*pic_ctx
,
49 av_unused
const uint8_t *buffer
,
50 av_unused
uint32_t size
)
52 pic_ctx
->bitstream_buffers_allocated
= 0;
53 pic_ctx
->bitstream_buffers_used
= 0;
54 pic_ctx
->bitstream_buffers
= NULL
;
58 #if CONFIG_H263_VDPAU_HWACCEL || CONFIG_MPEG1_VDPAU_HWACCEL || \
59 CONFIG_MPEG2_VDPAU_HWACCEL || CONFIG_MPEG4_VDPAU_HWACCEL || \
60 CONFIG_VC1_VDPAU_HWACCEL || CONFIG_WMV3_VDPAU_HWACCEL
61 int ff_vdpau_mpeg_end_frame(AVCodecContext
*avctx
)
64 AVVDPAUContext
*hwctx
= avctx
->hwaccel_context
;
65 MpegEncContext
*s
= avctx
->priv_data
;
66 Picture
*pic
= s
->current_picture_ptr
;
67 struct vdpau_picture_context
*pic_ctx
= pic
->hwaccel_picture_private
;
68 VdpVideoSurface surf
= ff_vdpau_get_surface_id(pic
->f
);
71 FF_DISABLE_DEPRECATION_WARNINGS
72 hwctx
->info
= pic_ctx
->info
;
73 hwctx
->bitstream_buffers
= pic_ctx
->bitstream_buffers
;
74 hwctx
->bitstream_buffers_used
= pic_ctx
->bitstream_buffers_used
;
75 hwctx
->bitstream_buffers_allocated
= pic_ctx
->bitstream_buffers_allocated
;
76 FF_ENABLE_DEPRECATION_WARNINGS
80 res
= hwctx
->render2(avctx
, pic
->f
, (void *)&pic_ctx
->info
,
81 pic_ctx
->bitstream_buffers_used
, pic_ctx
->bitstream_buffers
);
83 hwctx
->render(hwctx
->decoder
, surf
, (void *)&pic_ctx
->info
,
84 pic_ctx
->bitstream_buffers_used
, pic_ctx
->bitstream_buffers
);
86 ff_mpeg_draw_horiz_band(s
, 0, s
->avctx
->height
);
87 av_freep(&pic_ctx
->bitstream_buffers
);
90 FF_DISABLE_DEPRECATION_WARNINGS
91 hwctx
->bitstream_buffers
= NULL
;
92 hwctx
->bitstream_buffers_used
= 0;
93 hwctx
->bitstream_buffers_allocated
= 0;
94 FF_ENABLE_DEPRECATION_WARNINGS
101 int ff_vdpau_add_buffer(struct vdpau_picture_context
*pic_ctx
,
102 const uint8_t *buf
, uint32_t size
)
104 VdpBitstreamBuffer
*buffers
= pic_ctx
->bitstream_buffers
;
106 buffers
= av_fast_realloc(buffers
, &pic_ctx
->bitstream_buffers_allocated
,
107 (pic_ctx
->bitstream_buffers_used
+ 1) * sizeof(*buffers
));
109 return AVERROR(ENOMEM
);
111 pic_ctx
->bitstream_buffers
= buffers
;
112 buffers
+= pic_ctx
->bitstream_buffers_used
++;
114 buffers
->struct_version
= VDP_BITSTREAM_BUFFER_VERSION
;
115 buffers
->bitstream
= buf
;
116 buffers
->bitstream_bytes
= size
;
120 /* Obsolete non-hwaccel VDPAU support below... */
122 void ff_vdpau_h264_set_reference_frames(H264Context
*h
)
124 struct vdpau_render_state
*render
, *render_ref
;
125 VdpReferenceFrameH264
*rf
, *rf2
;
127 int i
, list
, pic_frame_idx
;
129 render
= (struct vdpau_render_state
*)h
->cur_pic_ptr
->f
.data
[0];
132 rf
= &render
->info
.h264
.referenceFrames
[0];
133 #define H264_RF_COUNT FF_ARRAY_ELEMS(render->info.h264.referenceFrames)
135 for (list
= 0; list
< 2; ++list
) {
136 H264Picture
**lp
= list
? h
->long_ref
: h
->short_ref
;
137 int ls
= list
? 16 : h
->short_ref_count
;
139 for (i
= 0; i
< ls
; ++i
) {
141 if (!pic
|| !pic
->reference
)
143 pic_frame_idx
= pic
->long_ref
? pic
->pic_id
: pic
->frame_num
;
145 render_ref
= (struct vdpau_render_state
*)pic
->f
.data
[0];
148 rf2
= &render
->info
.h264
.referenceFrames
[0];
151 (rf2
->surface
== render_ref
->surface
)
152 && (rf2
->is_long_term
== pic
->long_ref
)
153 && (rf2
->frame_idx
== pic_frame_idx
)
159 rf2
->top_is_reference
|= (pic
->reference
& PICT_TOP_FIELD
) ? VDP_TRUE
: VDP_FALSE
;
160 rf2
->bottom_is_reference
|= (pic
->reference
& PICT_BOTTOM_FIELD
) ? VDP_TRUE
: VDP_FALSE
;
164 if (rf
>= &render
->info
.h264
.referenceFrames
[H264_RF_COUNT
])
167 rf
->surface
= render_ref
->surface
;
168 rf
->is_long_term
= pic
->long_ref
;
169 rf
->top_is_reference
= (pic
->reference
& PICT_TOP_FIELD
) ? VDP_TRUE
: VDP_FALSE
;
170 rf
->bottom_is_reference
= (pic
->reference
& PICT_BOTTOM_FIELD
) ? VDP_TRUE
: VDP_FALSE
;
171 rf
->field_order_cnt
[0] = pic
->field_poc
[0];
172 rf
->field_order_cnt
[1] = pic
->field_poc
[1];
173 rf
->frame_idx
= pic_frame_idx
;
179 for (; rf
< &render
->info
.h264
.referenceFrames
[H264_RF_COUNT
]; ++rf
) {
180 rf
->surface
= VDP_INVALID_HANDLE
;
181 rf
->is_long_term
= 0;
182 rf
->top_is_reference
= 0;
183 rf
->bottom_is_reference
= 0;
184 rf
->field_order_cnt
[0] = 0;
185 rf
->field_order_cnt
[1] = 0;
190 void ff_vdpau_add_data_chunk(uint8_t *data
, const uint8_t *buf
, int buf_size
)
192 struct vdpau_render_state
*render
= (struct vdpau_render_state
*)data
;
195 render
->bitstream_buffers
= av_fast_realloc(
196 render
->bitstream_buffers
,
197 &render
->bitstream_buffers_allocated
,
198 sizeof(*render
->bitstream_buffers
)*(render
->bitstream_buffers_used
+ 1)
201 render
->bitstream_buffers
[render
->bitstream_buffers_used
].struct_version
= VDP_BITSTREAM_BUFFER_VERSION
;
202 render
->bitstream_buffers
[render
->bitstream_buffers_used
].bitstream
= buf
;
203 render
->bitstream_buffers
[render
->bitstream_buffers_used
].bitstream_bytes
= buf_size
;
204 render
->bitstream_buffers_used
++;
207 #if CONFIG_H264_VDPAU_DECODER
208 void ff_vdpau_h264_picture_start(H264Context
*h
)
210 struct vdpau_render_state
*render
;
213 render
= (struct vdpau_render_state
*)h
->cur_pic_ptr
->f
.data
[0];
216 for (i
= 0; i
< 2; ++i
) {
217 int foc
= h
->cur_pic_ptr
->field_poc
[i
];
220 render
->info
.h264
.field_order_cnt
[i
] = foc
;
223 render
->info
.h264
.frame_num
= h
->frame_num
;
226 void ff_vdpau_h264_picture_complete(H264Context
*h
)
228 struct vdpau_render_state
*render
;
230 render
= (struct vdpau_render_state
*)h
->cur_pic_ptr
->f
.data
[0];
233 render
->info
.h264
.slice_count
= h
->slice_num
;
234 if (render
->info
.h264
.slice_count
< 1)
237 render
->info
.h264
.is_reference
= (h
->cur_pic_ptr
->reference
& 3) ? VDP_TRUE
: VDP_FALSE
;
238 render
->info
.h264
.field_pic_flag
= h
->picture_structure
!= PICT_FRAME
;
239 render
->info
.h264
.bottom_field_flag
= h
->picture_structure
== PICT_BOTTOM_FIELD
;
240 render
->info
.h264
.num_ref_frames
= h
->sps
.ref_frame_count
;
241 render
->info
.h264
.mb_adaptive_frame_field_flag
= h
->sps
.mb_aff
&& !render
->info
.h264
.field_pic_flag
;
242 render
->info
.h264
.constrained_intra_pred_flag
= h
->pps
.constrained_intra_pred
;
243 render
->info
.h264
.weighted_pred_flag
= h
->pps
.weighted_pred
;
244 render
->info
.h264
.weighted_bipred_idc
= h
->pps
.weighted_bipred_idc
;
245 render
->info
.h264
.frame_mbs_only_flag
= h
->sps
.frame_mbs_only_flag
;
246 render
->info
.h264
.transform_8x8_mode_flag
= h
->pps
.transform_8x8_mode
;
247 render
->info
.h264
.chroma_qp_index_offset
= h
->pps
.chroma_qp_index_offset
[0];
248 render
->info
.h264
.second_chroma_qp_index_offset
= h
->pps
.chroma_qp_index_offset
[1];
249 render
->info
.h264
.pic_init_qp_minus26
= h
->pps
.init_qp
- 26;
250 render
->info
.h264
.num_ref_idx_l0_active_minus1
= h
->pps
.ref_count
[0] - 1;
251 render
->info
.h264
.num_ref_idx_l1_active_minus1
= h
->pps
.ref_count
[1] - 1;
252 render
->info
.h264
.log2_max_frame_num_minus4
= h
->sps
.log2_max_frame_num
- 4;
253 render
->info
.h264
.pic_order_cnt_type
= h
->sps
.poc_type
;
254 render
->info
.h264
.log2_max_pic_order_cnt_lsb_minus4
= h
->sps
.poc_type
? 0 : h
->sps
.log2_max_poc_lsb
- 4;
255 render
->info
.h264
.delta_pic_order_always_zero_flag
= h
->sps
.delta_pic_order_always_zero_flag
;
256 render
->info
.h264
.direct_8x8_inference_flag
= h
->sps
.direct_8x8_inference_flag
;
257 render
->info
.h264
.entropy_coding_mode_flag
= h
->pps
.cabac
;
258 render
->info
.h264
.pic_order_present_flag
= h
->pps
.pic_order_present
;
259 render
->info
.h264
.deblocking_filter_control_present_flag
= h
->pps
.deblocking_filter_parameters_present
;
260 render
->info
.h264
.redundant_pic_cnt_present_flag
= h
->pps
.redundant_pic_cnt_present
;
261 memcpy(render
->info
.h264
.scaling_lists_4x4
, h
->pps
.scaling_matrix4
, sizeof(render
->info
.h264
.scaling_lists_4x4
));
262 memcpy(render
->info
.h264
.scaling_lists_8x8
[0], h
->pps
.scaling_matrix8
[0], sizeof(render
->info
.h264
.scaling_lists_8x8
[0]));
263 memcpy(render
->info
.h264
.scaling_lists_8x8
[1], h
->pps
.scaling_matrix8
[3], sizeof(render
->info
.h264
.scaling_lists_8x8
[0]));
265 ff_h264_draw_horiz_band(h
, 0, h
->avctx
->height
);
266 render
->bitstream_buffers_used
= 0;
268 #endif /* CONFIG_H264_VDPAU_DECODER */
270 #if CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER
271 void ff_vdpau_mpeg_picture_complete(MpegEncContext
*s
, const uint8_t *buf
,
272 int buf_size
, int slice_count
)
274 struct vdpau_render_state
*render
, *last
, *next
;
277 if (!s
->current_picture_ptr
) return;
279 render
= (struct vdpau_render_state
*)s
->current_picture_ptr
->f
->data
[0];
282 /* fill VdpPictureInfoMPEG1Or2 struct */
283 render
->info
.mpeg
.picture_structure
= s
->picture_structure
;
284 render
->info
.mpeg
.picture_coding_type
= s
->pict_type
;
285 render
->info
.mpeg
.intra_dc_precision
= s
->intra_dc_precision
;
286 render
->info
.mpeg
.frame_pred_frame_dct
= s
->frame_pred_frame_dct
;
287 render
->info
.mpeg
.concealment_motion_vectors
= s
->concealment_motion_vectors
;
288 render
->info
.mpeg
.intra_vlc_format
= s
->intra_vlc_format
;
289 render
->info
.mpeg
.alternate_scan
= s
->alternate_scan
;
290 render
->info
.mpeg
.q_scale_type
= s
->q_scale_type
;
291 render
->info
.mpeg
.top_field_first
= s
->top_field_first
;
292 render
->info
.mpeg
.full_pel_forward_vector
= s
->full_pel
[0]; // MPEG-1 only. Set 0 for MPEG-2
293 render
->info
.mpeg
.full_pel_backward_vector
= s
->full_pel
[1]; // MPEG-1 only. Set 0 for MPEG-2
294 render
->info
.mpeg
.f_code
[0][0] = s
->mpeg_f_code
[0][0]; // For MPEG-1 fill both horiz. & vert.
295 render
->info
.mpeg
.f_code
[0][1] = s
->mpeg_f_code
[0][1];
296 render
->info
.mpeg
.f_code
[1][0] = s
->mpeg_f_code
[1][0];
297 render
->info
.mpeg
.f_code
[1][1] = s
->mpeg_f_code
[1][1];
298 for (i
= 0; i
< 64; ++i
) {
299 render
->info
.mpeg
.intra_quantizer_matrix
[i
] = s
->intra_matrix
[i
];
300 render
->info
.mpeg
.non_intra_quantizer_matrix
[i
] = s
->inter_matrix
[i
];
303 render
->info
.mpeg
.forward_reference
= VDP_INVALID_HANDLE
;
304 render
->info
.mpeg
.backward_reference
= VDP_INVALID_HANDLE
;
306 switch(s
->pict_type
){
307 case AV_PICTURE_TYPE_B
:
308 next
= (struct vdpau_render_state
*)s
->next_picture
.f
->data
[0];
310 render
->info
.mpeg
.backward_reference
= next
->surface
;
311 // no return here, going to set forward prediction
312 case AV_PICTURE_TYPE_P
:
313 last
= (struct vdpau_render_state
*)s
->last_picture
.f
->data
[0];
314 if (!last
) // FIXME: Does this test make sense?
315 last
= render
; // predict second field from the first
316 render
->info
.mpeg
.forward_reference
= last
->surface
;
319 ff_vdpau_add_data_chunk(s
->current_picture_ptr
->f
->data
[0], buf
, buf_size
);
321 render
->info
.mpeg
.slice_count
= slice_count
;
324 ff_mpeg_draw_horiz_band(s
, 0, s
->avctx
->height
);
325 render
->bitstream_buffers_used
= 0;
327 #endif /* CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER */
329 #if CONFIG_VC1_VDPAU_DECODER
330 void ff_vdpau_vc1_decode_picture(MpegEncContext
*s
, const uint8_t *buf
,
333 VC1Context
*v
= s
->avctx
->priv_data
;
334 struct vdpau_render_state
*render
, *last
, *next
;
336 render
= (struct vdpau_render_state
*)s
->current_picture
.f
->data
[0];
339 /* fill LvPictureInfoVC1 struct */
340 render
->info
.vc1
.frame_coding_mode
= v
->fcm
? v
->fcm
+ 1 : 0;
341 render
->info
.vc1
.postprocflag
= v
->postprocflag
;
342 render
->info
.vc1
.pulldown
= v
->broadcast
;
343 render
->info
.vc1
.interlace
= v
->interlace
;
344 render
->info
.vc1
.tfcntrflag
= v
->tfcntrflag
;
345 render
->info
.vc1
.finterpflag
= v
->finterpflag
;
346 render
->info
.vc1
.psf
= v
->psf
;
347 render
->info
.vc1
.dquant
= v
->dquant
;
348 render
->info
.vc1
.panscan_flag
= v
->panscanflag
;
349 render
->info
.vc1
.refdist_flag
= v
->refdist_flag
;
350 render
->info
.vc1
.quantizer
= v
->quantizer_mode
;
351 render
->info
.vc1
.extended_mv
= v
->extended_mv
;
352 render
->info
.vc1
.extended_dmv
= v
->extended_dmv
;
353 render
->info
.vc1
.overlap
= v
->overlap
;
354 render
->info
.vc1
.vstransform
= v
->vstransform
;
355 render
->info
.vc1
.loopfilter
= v
->s
.loop_filter
;
356 render
->info
.vc1
.fastuvmc
= v
->fastuvmc
;
357 render
->info
.vc1
.range_mapy_flag
= v
->range_mapy_flag
;
358 render
->info
.vc1
.range_mapy
= v
->range_mapy
;
359 render
->info
.vc1
.range_mapuv_flag
= v
->range_mapuv_flag
;
360 render
->info
.vc1
.range_mapuv
= v
->range_mapuv
;
361 /* Specific to simple/main profile only */
362 render
->info
.vc1
.multires
= v
->multires
;
363 render
->info
.vc1
.syncmarker
= v
->resync_marker
;
364 render
->info
.vc1
.rangered
= v
->rangered
| (v
->rangeredfrm
<< 1);
365 render
->info
.vc1
.maxbframes
= v
->s
.max_b_frames
;
367 render
->info
.vc1
.deblockEnable
= v
->postprocflag
& 1;
368 render
->info
.vc1
.pquant
= v
->pq
;
370 render
->info
.vc1
.forward_reference
= VDP_INVALID_HANDLE
;
371 render
->info
.vc1
.backward_reference
= VDP_INVALID_HANDLE
;
374 render
->info
.vc1
.picture_type
= 4;
376 render
->info
.vc1
.picture_type
= s
->pict_type
- 1 + s
->pict_type
/ 3;
378 switch(s
->pict_type
){
379 case AV_PICTURE_TYPE_B
:
380 next
= (struct vdpau_render_state
*)s
->next_picture
.f
->data
[0];
382 render
->info
.vc1
.backward_reference
= next
->surface
;
383 // no break here, going to set forward prediction
384 case AV_PICTURE_TYPE_P
:
385 last
= (struct vdpau_render_state
*)s
->last_picture
.f
->data
[0];
386 if (!last
) // FIXME: Does this test make sense?
387 last
= render
; // predict second field from the first
388 render
->info
.vc1
.forward_reference
= last
->surface
;
391 ff_vdpau_add_data_chunk(s
->current_picture_ptr
->f
->data
[0], buf
, buf_size
);
393 render
->info
.vc1
.slice_count
= 1;
395 ff_mpeg_draw_horiz_band(s
, 0, s
->avctx
->height
);
396 render
->bitstream_buffers_used
= 0;
398 #endif /* (CONFIG_VC1_VDPAU_DECODER */
400 #if CONFIG_MPEG4_VDPAU_DECODER
401 void ff_vdpau_mpeg4_decode_picture(Mpeg4DecContext
*ctx
, const uint8_t *buf
,
404 MpegEncContext
*s
= &ctx
->m
;
405 struct vdpau_render_state
*render
, *last
, *next
;
408 if (!s
->current_picture_ptr
) return;
410 render
= (struct vdpau_render_state
*)s
->current_picture_ptr
->f
->data
[0];
413 /* fill VdpPictureInfoMPEG4Part2 struct */
414 render
->info
.mpeg4
.trd
[0] = s
->pp_time
;
415 render
->info
.mpeg4
.trb
[0] = s
->pb_time
;
416 render
->info
.mpeg4
.trd
[1] = s
->pp_field_time
>> 1;
417 render
->info
.mpeg4
.trb
[1] = s
->pb_field_time
>> 1;
418 render
->info
.mpeg4
.vop_time_increment_resolution
= s
->avctx
->time_base
.den
;
419 render
->info
.mpeg4
.vop_coding_type
= 0;
420 render
->info
.mpeg4
.vop_fcode_forward
= s
->f_code
;
421 render
->info
.mpeg4
.vop_fcode_backward
= s
->b_code
;
422 render
->info
.mpeg4
.resync_marker_disable
= !ctx
->resync_marker
;
423 render
->info
.mpeg4
.interlaced
= !s
->progressive_sequence
;
424 render
->info
.mpeg4
.quant_type
= s
->mpeg_quant
;
425 render
->info
.mpeg4
.quarter_sample
= s
->quarter_sample
;
426 render
->info
.mpeg4
.short_video_header
= s
->avctx
->codec
->id
== AV_CODEC_ID_H263
;
427 render
->info
.mpeg4
.rounding_control
= s
->no_rounding
;
428 render
->info
.mpeg4
.alternate_vertical_scan_flag
= s
->alternate_scan
;
429 render
->info
.mpeg4
.top_field_first
= s
->top_field_first
;
430 for (i
= 0; i
< 64; ++i
) {
431 render
->info
.mpeg4
.intra_quantizer_matrix
[i
] = s
->intra_matrix
[i
];
432 render
->info
.mpeg4
.non_intra_quantizer_matrix
[i
] = s
->inter_matrix
[i
];
434 render
->info
.mpeg4
.forward_reference
= VDP_INVALID_HANDLE
;
435 render
->info
.mpeg4
.backward_reference
= VDP_INVALID_HANDLE
;
437 switch (s
->pict_type
) {
438 case AV_PICTURE_TYPE_B
:
439 next
= (struct vdpau_render_state
*)s
->next_picture
.f
->data
[0];
441 render
->info
.mpeg4
.backward_reference
= next
->surface
;
442 render
->info
.mpeg4
.vop_coding_type
= 2;
443 // no break here, going to set forward prediction
444 case AV_PICTURE_TYPE_P
:
445 last
= (struct vdpau_render_state
*)s
->last_picture
.f
->data
[0];
447 render
->info
.mpeg4
.forward_reference
= last
->surface
;
450 ff_vdpau_add_data_chunk(s
->current_picture_ptr
->f
->data
[0], buf
, buf_size
);
452 ff_mpeg_draw_horiz_band(s
, 0, s
->avctx
->height
);
453 render
->bitstream_buffers_used
= 0;
455 #endif /* CONFIG_MPEG4_VDPAU_DECODER */
457 int av_vdpau_get_profile(AVCodecContext
*avctx
, VdpDecoderProfile
*profile
)
459 #define PROFILE(prof) \
465 switch (avctx
->codec_id
) {
466 case AV_CODEC_ID_MPEG1VIDEO
: PROFILE(VDP_DECODER_PROFILE_MPEG1
);
467 case AV_CODEC_ID_MPEG2VIDEO
:
468 switch (avctx
->profile
) {
469 case FF_PROFILE_MPEG2_MAIN
: PROFILE(VDP_DECODER_PROFILE_MPEG2_MAIN
);
470 case FF_PROFILE_MPEG2_SIMPLE
: PROFILE(VDP_DECODER_PROFILE_MPEG2_SIMPLE
);
471 default: return AVERROR(EINVAL
);
473 case AV_CODEC_ID_H263
: PROFILE(VDP_DECODER_PROFILE_MPEG4_PART2_ASP
);
474 case AV_CODEC_ID_MPEG4
:
475 switch (avctx
->profile
) {
476 case FF_PROFILE_MPEG4_SIMPLE
: PROFILE(VDP_DECODER_PROFILE_MPEG4_PART2_SP
);
477 case FF_PROFILE_MPEG4_ADVANCED_SIMPLE
: PROFILE(VDP_DECODER_PROFILE_MPEG4_PART2_ASP
);
478 default: return AVERROR(EINVAL
);
480 case AV_CODEC_ID_H264
:
481 switch (avctx
->profile
& ~FF_PROFILE_H264_INTRA
) {
482 case FF_PROFILE_H264_CONSTRAINED_BASELINE
:
483 case FF_PROFILE_H264_BASELINE
: PROFILE(VDP_DECODER_PROFILE_H264_BASELINE
);
484 case FF_PROFILE_H264_MAIN
: PROFILE(VDP_DECODER_PROFILE_H264_MAIN
);
485 case FF_PROFILE_H264_HIGH
: PROFILE(VDP_DECODER_PROFILE_H264_HIGH
);
486 default: return AVERROR(EINVAL
);
488 case AV_CODEC_ID_WMV3
:
489 case AV_CODEC_ID_VC1
:
490 switch (avctx
->profile
) {
491 case FF_PROFILE_VC1_SIMPLE
: PROFILE(VDP_DECODER_PROFILE_VC1_SIMPLE
);
492 case FF_PROFILE_VC1_MAIN
: PROFILE(VDP_DECODER_PROFILE_VC1_MAIN
);
493 case FF_PROFILE_VC1_ADVANCED
: PROFILE(VDP_DECODER_PROFILE_VC1_ADVANCED
);
494 default: return AVERROR(EINVAL
);
497 return AVERROR(EINVAL
);
500 AVVDPAUContext
*av_vdpau_alloc_context(void)
502 return av_mallocz(sizeof(AVVDPAUContext
));