Mercurial > libavcodec.hg
annotate vaapi_vc1.c @ 10795:342c2dbe0f94 libavcodec
More doxy
author | michael |
---|---|
date | Thu, 07 Jan 2010 15:12:31 +0000 |
parents | 1e0d87fc2818 |
children | 8a4984c5cacc |
rev | line source |
---|---|
9338 | 1 /* |
2 * VC-1 HW decode acceleration through VA API | |
3 * | |
4 * Copyright (C) 2008-2009 Splitted-Desktop Systems | |
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 "vaapi_internal.h" | |
24 #include "vc1.h" | |
25 #include "vc1data.h" | |
26 | |
27 /** Translates FFmpeg MV modes to VA API */ | |
28 static int get_VAMvModeVC1(enum MVModes mv_mode) | |
29 { | |
30 switch (mv_mode) { | |
31 case MV_PMODE_1MV_HPEL_BILIN: return VAMvMode1MvHalfPelBilinear; | |
32 case MV_PMODE_1MV: return VAMvMode1Mv; | |
33 case MV_PMODE_1MV_HPEL: return VAMvMode1MvHalfPel; | |
34 case MV_PMODE_MIXED_MV: return VAMvModeMixedMv; | |
35 case MV_PMODE_INTENSITY_COMP: return VAMvModeIntensityCompensation; | |
36 } | |
37 return 0; | |
38 } | |
39 | |
40 /** Checks whether the MVTYPEMB bitplane is present */ | |
41 static inline int vc1_has_MVTYPEMB_bitplane(VC1Context *v) | |
42 { | |
43 if (v->mv_type_is_raw) | |
44 return 0; | |
45 return (v->s.pict_type == FF_P_TYPE && | |
46 (v->mv_mode == MV_PMODE_MIXED_MV || | |
47 (v->mv_mode == MV_PMODE_INTENSITY_COMP && | |
48 v->mv_mode2 == MV_PMODE_MIXED_MV))); | |
49 } | |
50 | |
51 /** Checks whether the SKIPMB bitplane is present */ | |
52 static inline int vc1_has_SKIPMB_bitplane(VC1Context *v) | |
53 { | |
54 if (v->skip_is_raw) | |
55 return 0; | |
56 return (v->s.pict_type == FF_P_TYPE || | |
57 (v->s.pict_type == FF_B_TYPE && !v->bi_type)); | |
58 } | |
59 | |
60 /** Checks whether the DIRECTMB bitplane is present */ | |
61 static inline int vc1_has_DIRECTMB_bitplane(VC1Context *v) | |
62 { | |
63 if (v->dmb_is_raw) | |
64 return 0; | |
65 return v->s.pict_type == FF_B_TYPE && !v->bi_type; | |
66 } | |
67 | |
68 /** Checks whether the ACPRED bitplane is present */ | |
69 static inline int vc1_has_ACPRED_bitplane(VC1Context *v) | |
70 { | |
71 if (v->acpred_is_raw) | |
72 return 0; | |
73 return (v->profile == PROFILE_ADVANCED && | |
74 (v->s.pict_type == FF_I_TYPE || | |
75 (v->s.pict_type == FF_B_TYPE && v->bi_type))); | |
76 } | |
77 | |
78 /** Check whether the OVERFLAGS bitplane is present */ | |
79 static inline int vc1_has_OVERFLAGS_bitplane(VC1Context *v) | |
80 { | |
81 if (v->overflg_is_raw) | |
82 return 0; | |
83 return (v->profile == PROFILE_ADVANCED && | |
84 (v->s.pict_type == FF_I_TYPE || | |
85 (v->s.pict_type == FF_B_TYPE && v->bi_type)) && | |
86 (v->overlap && v->pq <= 8) && | |
87 v->condover == CONDOVER_SELECT); | |
88 } | |
89 | |
90 /** Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35) */ | |
91 static int vc1_get_PTYPE(VC1Context *v) | |
92 { | |
93 MpegEncContext * const s = &v->s; | |
94 switch (s->pict_type) { | |
95 case FF_I_TYPE: return 0; | |
96 case FF_P_TYPE: return v->p_frame_skipped ? 4 : 1; | |
97 case FF_B_TYPE: return v->bi_type ? 3 : 2; | |
98 } | |
99 return 0; | |
100 } | |
101 | |
102 /** Reconstruct bitstream MVMODE (7.1.1.32) */ | |
103 static inline VAMvModeVC1 vc1_get_MVMODE(VC1Context *v) | |
104 { | |
105 if (v->s.pict_type == FF_P_TYPE || | |
106 (v->s.pict_type == FF_B_TYPE && !v->bi_type)) | |
107 return get_VAMvModeVC1(v->mv_mode); | |
108 return 0; | |
109 } | |
110 | |
111 /** Reconstruct bitstream MVMODE2 (7.1.1.33) */ | |
112 static inline VAMvModeVC1 vc1_get_MVMODE2(VC1Context *v) | |
113 { | |
114 if (v->s.pict_type == FF_P_TYPE && v->mv_mode == MV_PMODE_INTENSITY_COMP) | |
115 return get_VAMvModeVC1(v->mv_mode2); | |
116 return 0; | |
117 } | |
118 | |
119 /** Pack FFmpeg bitplanes into a VABitPlaneBuffer element */ | |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
120 static inline void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *ff_bp[3], int x, int y, int stride) |
9338 | 121 { |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
122 const int bitplane_index = n / 2; |
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
123 const int ff_bp_index = y * stride + x; |
9338 | 124 uint8_t v = 0; |
125 if (ff_bp[0]) | |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
126 v = ff_bp[0][ff_bp_index]; |
9338 | 127 if (ff_bp[1]) |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
128 v |= ff_bp[1][ff_bp_index] << 1; |
9338 | 129 if (ff_bp[2]) |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
130 v |= ff_bp[2][ff_bp_index] << 2; |
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
131 bitplane[bitplane_index] = (bitplane[bitplane_index] << 4) | v; |
9338 | 132 } |
133 | |
134 static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size) | |
135 { | |
136 VC1Context * const v = avctx->priv_data; | |
137 MpegEncContext * const s = &v->s; | |
138 struct vaapi_context * const vactx = avctx->hwaccel_context; | |
139 VAPictureParameterBufferVC1 *pic_param; | |
140 | |
141 dprintf(avctx, "vaapi_vc1_start_frame()\n"); | |
142 | |
143 vactx->slice_param_size = sizeof(VASliceParameterBufferVC1); | |
144 | |
145 /* Fill in VAPictureParameterBufferVC1 */ | |
10724
de8d07d87c45
Rename ff_vaapi_alloc_picture() to ff_vaapi_alloc_pic_param().
gb
parents:
10723
diff
changeset
|
146 pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferVC1)); |
9338 | 147 if (!pic_param) |
148 return -1; | |
10725 | 149 pic_param->forward_reference_picture = VA_INVALID_ID; |
150 pic_param->backward_reference_picture = VA_INVALID_ID; | |
151 pic_param->inloop_decoded_picture = VA_INVALID_ID; | |
9338 | 152 pic_param->sequence_fields.value = 0; /* reset all bits */ |
153 pic_param->sequence_fields.bits.pulldown = v->broadcast; | |
154 pic_param->sequence_fields.bits.interlace = v->interlace; | |
155 pic_param->sequence_fields.bits.tfcntrflag = v->tfcntrflag; | |
156 pic_param->sequence_fields.bits.finterpflag = v->finterpflag; | |
157 pic_param->sequence_fields.bits.psf = v->psf; | |
158 pic_param->sequence_fields.bits.multires = v->multires; | |
159 pic_param->sequence_fields.bits.overlap = v->overlap; | |
160 pic_param->sequence_fields.bits.syncmarker = s->resync_marker; | |
161 pic_param->sequence_fields.bits.rangered = v->rangered; | |
162 pic_param->sequence_fields.bits.max_b_frames = s->avctx->max_b_frames; | |
163 pic_param->coded_width = s->avctx->coded_width; | |
164 pic_param->coded_height = s->avctx->coded_height; | |
165 pic_param->entrypoint_fields.value = 0; /* reset all bits */ | |
166 pic_param->entrypoint_fields.bits.broken_link = v->broken_link; | |
167 pic_param->entrypoint_fields.bits.closed_entry = v->closed_entry; | |
168 pic_param->entrypoint_fields.bits.panscan_flag = v->panscanflag; | |
169 pic_param->entrypoint_fields.bits.loopfilter = s->loop_filter; | |
170 pic_param->conditional_overlap_flag = v->condover; | |
171 pic_param->fast_uvmc_flag = v->fastuvmc; | |
172 pic_param->range_mapping_fields.value = 0; /* reset all bits */ | |
173 pic_param->range_mapping_fields.bits.luma_flag = v->range_mapy_flag; | |
174 pic_param->range_mapping_fields.bits.luma = v->range_mapy; | |
175 pic_param->range_mapping_fields.bits.chroma_flag = v->range_mapuv_flag; | |
176 pic_param->range_mapping_fields.bits.chroma = v->range_mapuv; | |
177 pic_param->b_picture_fraction = v->bfraction_lut_index; | |
178 pic_param->cbp_table = v->cbpcy_vlc ? v->cbpcy_vlc - ff_vc1_cbpcy_p_vlc : 0; | |
179 pic_param->mb_mode_table = 0; /* XXX: interlaced frame */ | |
180 pic_param->range_reduction_frame = v->rangeredfrm; | |
181 pic_param->rounding_control = v->rnd; | |
182 pic_param->post_processing = v->postproc; | |
183 pic_param->picture_resolution_index = v->respic; | |
184 pic_param->luma_scale = v->lumscale; | |
185 pic_param->luma_shift = v->lumshift; | |
186 pic_param->picture_fields.value = 0; /* reset all bits */ | |
187 pic_param->picture_fields.bits.picture_type = vc1_get_PTYPE(v); | |
188 pic_param->picture_fields.bits.frame_coding_mode = v->fcm; | |
189 pic_param->picture_fields.bits.top_field_first = v->tff; | |
190 pic_param->picture_fields.bits.is_first_field = v->fcm == 0; /* XXX: interlaced frame */ | |
191 pic_param->picture_fields.bits.intensity_compensation = v->mv_mode == MV_PMODE_INTENSITY_COMP; | |
192 pic_param->raw_coding.value = 0; /* reset all bits */ | |
193 pic_param->raw_coding.flags.mv_type_mb = v->mv_type_is_raw; | |
194 pic_param->raw_coding.flags.direct_mb = v->dmb_is_raw; | |
195 pic_param->raw_coding.flags.skip_mb = v->skip_is_raw; | |
196 pic_param->raw_coding.flags.field_tx = 0; /* XXX: interlaced frame */ | |
197 pic_param->raw_coding.flags.forward_mb = 0; /* XXX: interlaced frame */ | |
198 pic_param->raw_coding.flags.ac_pred = v->acpred_is_raw; | |
199 pic_param->raw_coding.flags.overflags = v->overflg_is_raw; | |
200 pic_param->bitplane_present.value = 0; /* reset all bits */ | |
201 pic_param->bitplane_present.flags.bp_mv_type_mb = vc1_has_MVTYPEMB_bitplane(v); | |
202 pic_param->bitplane_present.flags.bp_direct_mb = vc1_has_DIRECTMB_bitplane(v); | |
203 pic_param->bitplane_present.flags.bp_skip_mb = vc1_has_SKIPMB_bitplane(v); | |
204 pic_param->bitplane_present.flags.bp_field_tx = 0; /* XXX: interlaced frame */ | |
205 pic_param->bitplane_present.flags.bp_forward_mb = 0; /* XXX: interlaced frame */ | |
206 pic_param->bitplane_present.flags.bp_ac_pred = vc1_has_ACPRED_bitplane(v); | |
207 pic_param->bitplane_present.flags.bp_overflags = vc1_has_OVERFLAGS_bitplane(v); | |
208 pic_param->reference_fields.value = 0; /* reset all bits */ | |
209 pic_param->reference_fields.bits.reference_distance_flag = v->refdist_flag; | |
210 pic_param->reference_fields.bits.reference_distance = 0; /* XXX: interlaced frame */ | |
211 pic_param->reference_fields.bits.num_reference_pictures = 0; /* XXX: interlaced frame */ | |
212 pic_param->reference_fields.bits.reference_field_pic_indicator = 0; /* XXX: interlaced frame */ | |
213 pic_param->mv_fields.value = 0; /* reset all bits */ | |
214 pic_param->mv_fields.bits.mv_mode = vc1_get_MVMODE(v); | |
215 pic_param->mv_fields.bits.mv_mode2 = vc1_get_MVMODE2(v); | |
216 pic_param->mv_fields.bits.mv_table = s->mv_table_index; | |
217 pic_param->mv_fields.bits.two_mv_block_pattern_table = 0; /* XXX: interlaced frame */ | |
218 pic_param->mv_fields.bits.four_mv_switch = 0; /* XXX: interlaced frame */ | |
219 pic_param->mv_fields.bits.four_mv_block_pattern_table = 0; /* XXX: interlaced frame */ | |
220 pic_param->mv_fields.bits.extended_mv_flag = v->extended_mv; | |
221 pic_param->mv_fields.bits.extended_mv_range = v->mvrange; | |
222 pic_param->mv_fields.bits.extended_dmv_flag = v->extended_dmv; | |
223 pic_param->mv_fields.bits.extended_dmv_range = 0; /* XXX: interlaced frame */ | |
224 pic_param->pic_quantizer_fields.value = 0; /* reset all bits */ | |
225 pic_param->pic_quantizer_fields.bits.dquant = v->dquant; | |
226 pic_param->pic_quantizer_fields.bits.quantizer = v->quantizer_mode; | |
227 pic_param->pic_quantizer_fields.bits.half_qp = v->halfpq; | |
228 pic_param->pic_quantizer_fields.bits.pic_quantizer_scale = v->pq; | |
229 pic_param->pic_quantizer_fields.bits.pic_quantizer_type = v->pquantizer; | |
230 pic_param->pic_quantizer_fields.bits.dq_frame = v->dquantfrm; | |
231 pic_param->pic_quantizer_fields.bits.dq_profile = v->dqprofile; | |
232 pic_param->pic_quantizer_fields.bits.dq_sb_edge = v->dqprofile == DQPROFILE_SINGLE_EDGE ? v->dqsbedge : 0; | |
233 pic_param->pic_quantizer_fields.bits.dq_db_edge = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0; | |
234 pic_param->pic_quantizer_fields.bits.dq_binary_level = v->dqbilevel; | |
235 pic_param->pic_quantizer_fields.bits.alt_pic_quantizer = v->altpq; | |
236 pic_param->transform_fields.value = 0; /* reset all bits */ | |
237 pic_param->transform_fields.bits.variable_sized_transform_flag = v->vstransform; | |
238 pic_param->transform_fields.bits.mb_level_transform_type_flag = v->ttmbf; | |
239 pic_param->transform_fields.bits.frame_level_transform_type = v->ttfrm; | |
240 pic_param->transform_fields.bits.transform_ac_codingset_idx1 = v->c_ac_table_index; | |
241 pic_param->transform_fields.bits.transform_ac_codingset_idx2 = v->y_ac_table_index; | |
242 pic_param->transform_fields.bits.intra_transform_dc_table = v->s.dc_table_index; | |
243 | |
244 switch (s->pict_type) { | |
245 case FF_B_TYPE: | |
10723
3f08c340020f
Rename ff_vaapi_get_surface() to ff_vaapi_get_surface_id().
gb
parents:
9993
diff
changeset
|
246 pic_param->backward_reference_picture = ff_vaapi_get_surface_id(&s->next_picture); |
9338 | 247 // fall-through |
248 case FF_P_TYPE: | |
10723
3f08c340020f
Rename ff_vaapi_get_surface() to ff_vaapi_get_surface_id().
gb
parents:
9993
diff
changeset
|
249 pic_param->forward_reference_picture = ff_vaapi_get_surface_id(&s->last_picture); |
9338 | 250 break; |
251 } | |
252 | |
253 if (pic_param->bitplane_present.value) { | |
254 uint8_t *bitplane; | |
255 const uint8_t *ff_bp[3]; | |
256 int x, y, n; | |
257 | |
258 switch (s->pict_type) { | |
259 case FF_P_TYPE: | |
260 ff_bp[0] = pic_param->bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL; | |
261 ff_bp[1] = pic_param->bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL; | |
262 ff_bp[2] = pic_param->bitplane_present.flags.bp_mv_type_mb ? v->mv_type_mb_plane : NULL; | |
263 break; | |
264 case FF_B_TYPE: | |
265 if (!v->bi_type) { | |
266 ff_bp[0] = pic_param->bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL; | |
267 ff_bp[1] = pic_param->bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL; | |
268 ff_bp[2] = NULL; /* XXX: interlaced frame (FORWARD plane) */ | |
269 break; | |
270 } | |
271 /* fall-through (BI-type) */ | |
272 case FF_I_TYPE: | |
273 ff_bp[0] = NULL; /* XXX: interlaced frame (FIELDTX plane) */ | |
274 ff_bp[1] = pic_param->bitplane_present.flags.bp_ac_pred ? v->acpred_plane : NULL; | |
275 ff_bp[2] = pic_param->bitplane_present.flags.bp_overflags ? v->over_flags_plane : NULL; | |
276 break; | |
277 default: | |
278 ff_bp[0] = NULL; | |
279 ff_bp[1] = NULL; | |
280 ff_bp[2] = NULL; | |
281 break; | |
282 } | |
283 | |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
284 bitplane = ff_vaapi_alloc_bitplane(vactx, (s->mb_width * s->mb_height + 1) / 2); |
9338 | 285 if (!bitplane) |
286 return -1; | |
287 | |
288 n = 0; | |
10767
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
289 for (y = 0; y < s->mb_height; y++) |
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
290 for (x = 0; x < s->mb_width; x++, n++) |
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
291 vc1_pack_bitplanes(bitplane, n, ff_bp, x, y, s->mb_stride); |
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
292 if (n & 1) /* move last nibble to the high order */ |
1e0d87fc2818
VAAPI: fix WMV3 decoding of videos with an odd number of macroblocks per line.
gb
parents:
10725
diff
changeset
|
293 bitplane[n/2] <<= 4; |
9338 | 294 } |
295 return 0; | |
296 } | |
297 | |
298 static int vaapi_vc1_end_frame(AVCodecContext *avctx) | |
299 { | |
300 VC1Context * const v = avctx->priv_data; | |
301 | |
302 return ff_vaapi_common_end_frame(&v->s); | |
303 } | |
304 | |
305 static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) | |
306 { | |
307 VC1Context * const v = avctx->priv_data; | |
308 MpegEncContext * const s = &v->s; | |
309 VASliceParameterBufferVC1 *slice_param; | |
310 | |
311 dprintf(avctx, "vaapi_vc1_decode_slice(): buffer %p, size %d\n", buffer, size); | |
312 | |
313 /* Current bit buffer is beyond any marker for VC-1, so skip it */ | |
314 if (avctx->codec_id == CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) { | |
315 buffer += 4; | |
316 size -= 4; | |
317 } | |
318 | |
319 /* Fill in VASliceParameterBufferVC1 */ | |
320 slice_param = (VASliceParameterBufferVC1 *)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size); | |
321 if (!slice_param) | |
322 return -1; | |
323 slice_param->macroblock_offset = get_bits_count(&s->gb); | |
324 slice_param->slice_vertical_position = s->mb_y; | |
325 return 0; | |
326 } | |
327 | |
328 #if CONFIG_WMV3_VAAPI_HWACCEL | |
329 AVHWAccel wmv3_vaapi_hwaccel = { | |
330 .name = "wmv3_vaapi", | |
331 .type = CODEC_TYPE_VIDEO, | |
332 .id = CODEC_ID_WMV3, | |
333 .pix_fmt = PIX_FMT_VAAPI_VLD, | |
334 .capabilities = 0, | |
335 .start_frame = vaapi_vc1_start_frame, | |
336 .end_frame = vaapi_vc1_end_frame, | |
337 .decode_slice = vaapi_vc1_decode_slice, | |
338 .priv_data_size = 0, | |
339 }; | |
340 #endif | |
341 | |
342 AVHWAccel vc1_vaapi_hwaccel = { | |
343 .name = "vc1_vaapi", | |
344 .type = CODEC_TYPE_VIDEO, | |
345 .id = CODEC_ID_VC1, | |
346 .pix_fmt = PIX_FMT_VAAPI_VLD, | |
347 .capabilities = 0, | |
348 .start_frame = vaapi_vc1_start_frame, | |
349 .end_frame = vaapi_vc1_end_frame, | |
350 .decode_slice = vaapi_vc1_decode_slice, | |
351 .priv_data_size = 0, | |
352 }; |