2 * Copyright © 2011 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 * Xiang Haihao <haihao.xiang@intel.com>
34 #include <va/va_backend.h>
36 #include "intel_batchbuffer.h"
37 #include "intel_driver.h"
39 #include "i965_defines.h"
40 #include "i965_drv_video.h"
44 #define DMV_SIZE 0x88000 /* 557056 bytes for a frame */
46 static const uint32_t zigzag_direct[64] = {
47 0, 1, 8, 16, 9, 2, 3, 10,
48 17, 24, 32, 25, 18, 11, 4, 5,
49 12, 19, 26, 33, 40, 48, 41, 34,
50 27, 20, 13, 6, 7, 14, 21, 28,
51 35, 42, 49, 56, 57, 50, 43, 36,
52 29, 22, 15, 23, 30, 37, 44, 51,
53 58, 59, 52, 45, 38, 31, 39, 46,
54 53, 60, 61, 54, 47, 55, 62, 63
58 gen7_mfd_avc_frame_store_index(VADriverContextP ctx,
59 VAPictureParameterBufferH264 *pic_param,
60 struct gen7_mfd_context *gen7_mfd_context)
62 struct i965_driver_data *i965 = i965_driver_data(ctx);
65 assert(ARRAY_ELEMS(gen7_mfd_context->reference_surface) == ARRAY_ELEMS(pic_param->ReferenceFrames));
67 for (i = 0; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++) {
70 if (gen7_mfd_context->reference_surface[i].surface_id == VA_INVALID_ID)
73 for (j = 0; j < ARRAY_ELEMS(pic_param->ReferenceFrames); j++) {
74 VAPictureH264 *ref_pic = &pic_param->ReferenceFrames[j];
75 if (ref_pic->flags & VA_PICTURE_H264_INVALID)
78 if (gen7_mfd_context->reference_surface[i].surface_id == ref_pic->picture_id) {
85 struct object_surface *obj_surface = SURFACE(gen7_mfd_context->reference_surface[i].surface_id);
86 obj_surface->flags &= ~SURFACE_REFERENCED;
88 if ((obj_surface->flags & SURFACE_ALL_MASK) == SURFACE_DISPLAYED) {
89 dri_bo_unreference(obj_surface->bo);
90 obj_surface->bo = NULL;
91 obj_surface->flags &= ~SURFACE_REF_DIS_MASK;
94 if (obj_surface->free_private_data)
95 obj_surface->free_private_data(&obj_surface->private_data);
97 gen7_mfd_context->reference_surface[i].surface_id = VA_INVALID_ID;
98 gen7_mfd_context->reference_surface[i].frame_store_id = -1;
102 for (i = 0; i < ARRAY_ELEMS(pic_param->ReferenceFrames); i++) {
103 VAPictureH264 *ref_pic = &pic_param->ReferenceFrames[i];
106 if (ref_pic->flags & VA_PICTURE_H264_INVALID)
109 for (j = 0; j < ARRAY_ELEMS(gen7_mfd_context->reference_surface); j++) {
110 if (gen7_mfd_context->reference_surface[j].surface_id == VA_INVALID_ID)
113 if (gen7_mfd_context->reference_surface[j].surface_id == ref_pic->picture_id) {
121 struct object_surface *obj_surface = SURFACE(ref_pic->picture_id);
124 i965_check_alloc_surface_bo(ctx, obj_surface, 1);
126 for (frame_idx = 0; frame_idx < ARRAY_ELEMS(gen7_mfd_context->reference_surface); frame_idx++) {
127 for (j = 0; j < ARRAY_ELEMS(gen7_mfd_context->reference_surface); j++) {
128 if (gen7_mfd_context->reference_surface[j].surface_id == VA_INVALID_ID)
131 if (gen7_mfd_context->reference_surface[j].frame_store_id == frame_idx)
135 if (j == ARRAY_ELEMS(gen7_mfd_context->reference_surface))
139 assert(frame_idx < ARRAY_ELEMS(gen7_mfd_context->reference_surface));
141 for (j = 0; j < ARRAY_ELEMS(gen7_mfd_context->reference_surface); j++) {
142 if (gen7_mfd_context->reference_surface[j].surface_id == VA_INVALID_ID) {
143 gen7_mfd_context->reference_surface[j].surface_id = ref_pic->picture_id;
144 gen7_mfd_context->reference_surface[j].frame_store_id = frame_idx;
152 for (i = 0; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface) - 1; i++) {
153 if (gen7_mfd_context->reference_surface[i].surface_id != VA_INVALID_ID &&
154 gen7_mfd_context->reference_surface[i].frame_store_id == i)
157 for (j = i + 1; j < ARRAY_ELEMS(gen7_mfd_context->reference_surface); j++) {
158 if (gen7_mfd_context->reference_surface[j].surface_id != VA_INVALID_ID &&
159 gen7_mfd_context->reference_surface[j].frame_store_id == i) {
160 VASurfaceID id = gen7_mfd_context->reference_surface[i].surface_id;
161 int frame_idx = gen7_mfd_context->reference_surface[i].frame_store_id;
163 gen7_mfd_context->reference_surface[i].surface_id = gen7_mfd_context->reference_surface[j].surface_id;
164 gen7_mfd_context->reference_surface[i].frame_store_id = gen7_mfd_context->reference_surface[j].frame_store_id;
165 gen7_mfd_context->reference_surface[j].surface_id = id;
166 gen7_mfd_context->reference_surface[j].frame_store_id = frame_idx;
174 gen7_mfd_free_avc_surface(void **data)
176 struct gen7_avc_surface *gen7_avc_surface = *data;
178 if (!gen7_avc_surface)
181 dri_bo_unreference(gen7_avc_surface->dmv_top);
182 gen7_avc_surface->dmv_top = NULL;
183 dri_bo_unreference(gen7_avc_surface->dmv_bottom);
184 gen7_avc_surface->dmv_bottom = NULL;
186 free(gen7_avc_surface);
191 gen7_mfd_init_avc_surface(VADriverContextP ctx,
192 VAPictureParameterBufferH264 *pic_param,
193 struct object_surface *obj_surface)
195 struct i965_driver_data *i965 = i965_driver_data(ctx);
196 struct gen7_avc_surface *gen7_avc_surface = obj_surface->private_data;
198 obj_surface->free_private_data = gen7_mfd_free_avc_surface;
200 if (!gen7_avc_surface) {
201 gen7_avc_surface = calloc(sizeof(struct gen7_avc_surface), 1);
202 assert((obj_surface->size & 0x3f) == 0);
203 obj_surface->private_data = gen7_avc_surface;
206 gen7_avc_surface->dmv_bottom_flag = (pic_param->pic_fields.bits.field_pic_flag &&
207 !pic_param->seq_fields.bits.direct_8x8_inference_flag);
209 if (gen7_avc_surface->dmv_top == NULL) {
210 gen7_avc_surface->dmv_top = dri_bo_alloc(i965->intel.bufmgr,
211 "direct mv w/r buffer",
216 if (gen7_avc_surface->dmv_bottom_flag &&
217 gen7_avc_surface->dmv_bottom == NULL) {
218 gen7_avc_surface->dmv_bottom = dri_bo_alloc(i965->intel.bufmgr,
219 "direct mv w/r buffer",
226 gen7_mfd_pipe_mode_select(VADriverContextP ctx,
227 struct decode_state *decode_state,
229 struct gen7_mfd_context *gen7_mfd_context)
231 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
233 assert(standard_select == MFX_FORMAT_MPEG2 ||
234 standard_select == MFX_FORMAT_AVC ||
235 standard_select == MFX_FORMAT_VC1 ||
236 standard_select == MFX_FORMAT_JPEG);
238 BEGIN_BCS_BATCH(batch, 5); /* FIXME: 5 ??? */
239 OUT_BCS_BATCH(batch, MFX_PIPE_MODE_SELECT | (5 - 2));
241 (MFX_LONG_MODE << 17) | /* Currently only support long format */
242 (MFD_MODE_VLD << 15) | /* VLD mode */
243 (0 << 10) | /* disable Stream-Out */
244 (gen7_mfd_context->post_deblocking_output.valid << 9) | /* Post Deblocking Output */
245 (gen7_mfd_context->pre_deblocking_output.valid << 8) | /* Pre Deblocking Output */
246 (0 << 5) | /* not in stitch mode */
247 (MFX_CODEC_DECODE << 4) | /* decoding mode */
248 (standard_select << 0));
250 (0 << 4) | /* terminate if AVC motion and POC table error occurs */
251 (0 << 3) | /* terminate if AVC mbdata error occurs */
252 (0 << 2) | /* terminate if AVC CABAC/CAVLC decode error occurs */
255 OUT_BCS_BATCH(batch, 0); /* pic status/error report id */
256 OUT_BCS_BATCH(batch, 0); /* reserved */
257 ADVANCE_BCS_BATCH(batch);
261 gen7_mfd_surface_state(VADriverContextP ctx,
262 struct decode_state *decode_state,
264 struct gen7_mfd_context *gen7_mfd_context)
266 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
267 struct i965_driver_data *i965 = i965_driver_data(ctx);
268 struct object_surface *obj_surface = SURFACE(decode_state->current_render_target);
271 BEGIN_BCS_BATCH(batch, 6);
272 OUT_BCS_BATCH(batch, MFX_SURFACE_STATE | (6 - 2));
273 OUT_BCS_BATCH(batch, 0);
275 ((obj_surface->orig_height - 1) << 18) |
276 ((obj_surface->orig_width - 1) << 4));
278 (MFX_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface */
279 (1 << 27) | /* FIXME: set to 0 for JPEG */
280 (0 << 22) | /* surface object control state, FIXME??? */
281 ((obj_surface->width - 1) << 3) | /* pitch */
282 (0 << 2) | /* must be 0 for interleave U/V */
283 (1 << 1) | /* must be tiled */
284 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, must be 1 */
286 (0 << 16) | /* FIXME: fix it for JPEG */
287 (obj_surface->height)); /* FIXME: fix it for JPEG */
288 OUT_BCS_BATCH(batch, 0); /* FIXME: fix it for JPEG */
289 ADVANCE_BCS_BATCH(batch);
293 gen7_mfd_pipe_buf_addr_state(VADriverContextP ctx,
294 struct decode_state *decode_state,
296 struct gen7_mfd_context *gen7_mfd_context)
298 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
299 struct i965_driver_data *i965 = i965_driver_data(ctx);
302 BEGIN_BCS_BATCH(batch, 24);
303 OUT_BCS_BATCH(batch, MFX_PIPE_BUF_ADDR_STATE | (24 - 2));
304 if (gen7_mfd_context->pre_deblocking_output.valid)
305 OUT_BCS_RELOC(batch, gen7_mfd_context->pre_deblocking_output.bo,
306 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
309 OUT_BCS_BATCH(batch, 0);
311 if (gen7_mfd_context->post_deblocking_output.valid)
312 OUT_BCS_RELOC(batch, gen7_mfd_context->post_deblocking_output.bo,
313 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
316 OUT_BCS_BATCH(batch, 0);
318 OUT_BCS_BATCH(batch, 0); /* ignore for decoding */
319 OUT_BCS_BATCH(batch, 0); /* ignore for decoding */
321 if (gen7_mfd_context->intra_row_store_scratch_buffer.valid)
322 OUT_BCS_RELOC(batch, gen7_mfd_context->intra_row_store_scratch_buffer.bo,
323 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
326 OUT_BCS_BATCH(batch, 0);
328 if (gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.valid)
329 OUT_BCS_RELOC(batch, gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo,
330 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
333 OUT_BCS_BATCH(batch, 0);
336 for (i = 0; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++) {
337 struct object_surface *obj_surface;
339 if (gen7_mfd_context->reference_surface[i].surface_id != VA_INVALID_ID) {
340 obj_surface = SURFACE(gen7_mfd_context->reference_surface[i].surface_id);
341 assert(obj_surface && obj_surface->bo);
343 OUT_BCS_RELOC(batch, obj_surface->bo,
344 I915_GEM_DOMAIN_INSTRUCTION, 0,
347 OUT_BCS_BATCH(batch, 0);
351 OUT_BCS_BATCH(batch, 0); /* ignore DW23 for decoding */
352 ADVANCE_BCS_BATCH(batch);
356 gen7_mfd_ind_obj_base_addr_state(VADriverContextP ctx,
357 dri_bo *slice_data_bo,
359 struct gen7_mfd_context *gen7_mfd_context)
361 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
363 BEGIN_BCS_BATCH(batch, 11);
364 OUT_BCS_BATCH(batch, MFX_IND_OBJ_BASE_ADDR_STATE | (11 - 2));
365 OUT_BCS_RELOC(batch, slice_data_bo, I915_GEM_DOMAIN_INSTRUCTION, 0, 0); /* MFX Indirect Bitstream Object Base Address */
366 OUT_BCS_BATCH(batch, 0x80000000); /* must set, up to 2G */
367 OUT_BCS_BATCH(batch, 0); /* ignore for VLD mode */
368 OUT_BCS_BATCH(batch, 0);
369 OUT_BCS_BATCH(batch, 0); /* ignore for VLD mode */
370 OUT_BCS_BATCH(batch, 0);
371 OUT_BCS_BATCH(batch, 0); /* ignore for VLD mode */
372 OUT_BCS_BATCH(batch, 0);
373 OUT_BCS_BATCH(batch, 0); /* ignore for VLD mode */
374 OUT_BCS_BATCH(batch, 0);
375 ADVANCE_BCS_BATCH(batch);
379 gen7_mfd_bsp_buf_base_addr_state(VADriverContextP ctx,
380 struct decode_state *decode_state,
382 struct gen7_mfd_context *gen7_mfd_context)
384 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
386 BEGIN_BCS_BATCH(batch, 4);
387 OUT_BCS_BATCH(batch, MFX_BSP_BUF_BASE_ADDR_STATE | (4 - 2));
389 if (gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.valid)
390 OUT_BCS_RELOC(batch, gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo,
391 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
394 OUT_BCS_BATCH(batch, 0);
396 if (gen7_mfd_context->mpr_row_store_scratch_buffer.valid)
397 OUT_BCS_RELOC(batch, gen7_mfd_context->mpr_row_store_scratch_buffer.bo,
398 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
401 OUT_BCS_BATCH(batch, 0);
403 if (gen7_mfd_context->bitplane_read_buffer.valid)
404 OUT_BCS_RELOC(batch, gen7_mfd_context->bitplane_read_buffer.bo,
405 I915_GEM_DOMAIN_INSTRUCTION, 0,
408 OUT_BCS_BATCH(batch, 0);
410 ADVANCE_BCS_BATCH(batch);
414 gen7_mfd_aes_state(VADriverContextP ctx,
415 struct decode_state *decode_state,
422 gen7_mfd_qm_state(VADriverContextP ctx,
426 struct gen7_mfd_context *gen7_mfd_context)
428 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
429 unsigned int qm_buffer[16];
431 assert(qm_length <= 16 * 4);
432 memcpy(qm_buffer, qm, qm_length);
434 BEGIN_BCS_BATCH(batch, 18);
435 OUT_BCS_BATCH(batch, MFX_QM_STATE | (18 - 2));
436 OUT_BCS_BATCH(batch, qm_type << 0);
437 intel_batchbuffer_data(batch, qm_buffer, 16 * 4);
438 ADVANCE_BCS_BATCH(batch);
441 gen7_mfd_wait(VADriverContextP ctx,
442 struct decode_state *decode_state,
444 struct gen7_mfd_context *gen7_mfd_context)
446 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
448 BEGIN_BCS_BATCH(batch, 1);
449 OUT_BCS_BATCH(batch, MFX_WAIT | (1 << 8));
450 ADVANCE_BCS_BATCH(batch);
454 gen7_mfd_avc_img_state(VADriverContextP ctx,
455 struct decode_state *decode_state,
456 struct gen7_mfd_context *gen7_mfd_context)
458 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
461 int mbaff_frame_flag;
462 unsigned int width_in_mbs, height_in_mbs;
463 VAPictureParameterBufferH264 *pic_param;
465 assert(decode_state->pic_param && decode_state->pic_param->buffer);
466 pic_param = (VAPictureParameterBufferH264 *)decode_state->pic_param->buffer;
467 assert(!(pic_param->CurrPic.flags & VA_PICTURE_H264_INVALID));
469 if (decode_state->iq_matrix && decode_state->iq_matrix->buffer)
472 qm_present_flag = 0; /* built-in QM matrices */
474 if (pic_param->CurrPic.flags & VA_PICTURE_H264_TOP_FIELD)
476 else if (pic_param->CurrPic.flags & VA_PICTURE_H264_BOTTOM_FIELD)
481 if ((img_struct & 0x1) == 0x1) {
482 assert(pic_param->pic_fields.bits.field_pic_flag == 0x1);
484 assert(pic_param->pic_fields.bits.field_pic_flag == 0x0);
487 if (pic_param->seq_fields.bits.frame_mbs_only_flag) { /* a frame containing only frame macroblocks */
488 assert(pic_param->seq_fields.bits.mb_adaptive_frame_field_flag == 0);
489 assert(pic_param->pic_fields.bits.field_pic_flag == 0);
491 assert(pic_param->seq_fields.bits.direct_8x8_inference_flag == 1); /* see H.264 spec */
494 mbaff_frame_flag = (pic_param->seq_fields.bits.mb_adaptive_frame_field_flag &&
495 !pic_param->pic_fields.bits.field_pic_flag);
497 width_in_mbs = ((pic_param->picture_width_in_mbs_minus1 + 1) & 0xff);
498 height_in_mbs = ((pic_param->picture_height_in_mbs_minus1 + 1) & 0xff); /* frame height */
500 /* MFX unit doesn't support 4:2:2 and 4:4:4 picture */
501 assert(pic_param->seq_fields.bits.chroma_format_idc == 0 || /* monochrome picture */
502 pic_param->seq_fields.bits.chroma_format_idc == 1); /* 4:2:0 */
503 assert(pic_param->seq_fields.bits.residual_colour_transform_flag == 0); /* only available for 4:4:4 */
505 BEGIN_BCS_BATCH(batch, 16);
506 OUT_BCS_BATCH(batch, MFX_AVC_IMG_STATE | (16 - 2));
508 width_in_mbs * height_in_mbs);
510 ((height_in_mbs - 1) << 16) |
511 ((width_in_mbs - 1) << 0));
513 ((pic_param->second_chroma_qp_index_offset & 0x1f) << 24) |
514 ((pic_param->chroma_qp_index_offset & 0x1f) << 16) |
515 (0 << 14) | /* Max-bit conformance Intra flag ??? FIXME */
516 (0 << 13) | /* Max Macroblock size conformance Inter flag ??? FIXME */
517 (pic_param->pic_fields.bits.weighted_pred_flag << 12) | /* differ from GEN6 */
518 (pic_param->pic_fields.bits.weighted_bipred_idc << 10) |
521 (pic_param->seq_fields.bits.chroma_format_idc << 10) |
522 (pic_param->pic_fields.bits.entropy_coding_mode_flag << 7) |
523 ((!pic_param->pic_fields.bits.reference_pic_flag) << 6) |
524 (pic_param->pic_fields.bits.constrained_intra_pred_flag << 5) |
525 (pic_param->seq_fields.bits.direct_8x8_inference_flag << 4) |
526 (pic_param->pic_fields.bits.transform_8x8_mode_flag << 3) |
527 (pic_param->seq_fields.bits.frame_mbs_only_flag << 2) |
528 (mbaff_frame_flag << 1) |
529 (pic_param->pic_fields.bits.field_pic_flag << 0));
530 OUT_BCS_BATCH(batch, 0);
531 OUT_BCS_BATCH(batch, 0);
532 OUT_BCS_BATCH(batch, 0);
533 OUT_BCS_BATCH(batch, 0);
534 OUT_BCS_BATCH(batch, 0);
535 OUT_BCS_BATCH(batch, 0);
536 OUT_BCS_BATCH(batch, 0);
537 OUT_BCS_BATCH(batch, 0);
538 OUT_BCS_BATCH(batch, 0);
539 OUT_BCS_BATCH(batch, 0);
540 OUT_BCS_BATCH(batch, 0);
541 ADVANCE_BCS_BATCH(batch);
545 gen7_mfd_avc_qm_state(VADriverContextP ctx,
546 struct decode_state *decode_state,
547 struct gen7_mfd_context *gen7_mfd_context)
549 VAIQMatrixBufferH264 *iq_matrix;
550 VAPictureParameterBufferH264 *pic_param;
552 if (!decode_state->iq_matrix || !decode_state->iq_matrix->buffer)
555 iq_matrix = (VAIQMatrixBufferH264 *)decode_state->iq_matrix->buffer;
557 assert(decode_state->pic_param && decode_state->pic_param->buffer);
558 pic_param = (VAPictureParameterBufferH264 *)decode_state->pic_param->buffer;
560 gen7_mfd_qm_state(ctx, MFX_QM_AVC_4X4_INTRA_MATRIX, &iq_matrix->ScalingList4x4[0][0], 3 * 16, gen7_mfd_context);
561 gen7_mfd_qm_state(ctx, MFX_QM_AVC_4X4_INTER_MATRIX, &iq_matrix->ScalingList4x4[3][0], 3 * 16, gen7_mfd_context);
563 if (pic_param->pic_fields.bits.transform_8x8_mode_flag) {
564 gen7_mfd_qm_state(ctx, MFX_QM_AVC_8x8_INTRA_MATRIX, &iq_matrix->ScalingList8x8[0][0], 64, gen7_mfd_context);
565 gen7_mfd_qm_state(ctx, MFX_QM_AVC_8x8_INTER_MATRIX, &iq_matrix->ScalingList8x8[1][0], 64, gen7_mfd_context);
570 gen7_mfd_avc_directmode_state(VADriverContextP ctx,
571 VAPictureParameterBufferH264 *pic_param,
572 VASliceParameterBufferH264 *slice_param,
573 struct gen7_mfd_context *gen7_mfd_context)
575 struct i965_driver_data *i965 = i965_driver_data(ctx);
576 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
577 struct object_surface *obj_surface;
578 struct gen7_avc_surface *gen7_avc_surface;
579 VAPictureH264 *va_pic;
582 BEGIN_BCS_BATCH(batch, 69);
583 OUT_BCS_BATCH(batch, MFX_AVC_DIRECTMODE_STATE | (69 - 2));
585 /* reference surfaces 0..15 */
586 for (i = 0; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++) {
587 if (gen7_mfd_context->reference_surface[i].surface_id != VA_INVALID_ID) {
588 obj_surface = SURFACE(gen7_mfd_context->reference_surface[i].surface_id);
590 gen7_avc_surface = obj_surface->private_data;
592 if (gen7_avc_surface == NULL) {
593 OUT_BCS_BATCH(batch, 0);
594 OUT_BCS_BATCH(batch, 0);
596 OUT_BCS_RELOC(batch, gen7_avc_surface->dmv_top,
597 I915_GEM_DOMAIN_INSTRUCTION, 0,
600 if (gen7_avc_surface->dmv_bottom_flag == 1)
601 OUT_BCS_RELOC(batch, gen7_avc_surface->dmv_bottom,
602 I915_GEM_DOMAIN_INSTRUCTION, 0,
605 OUT_BCS_RELOC(batch, gen7_avc_surface->dmv_top,
606 I915_GEM_DOMAIN_INSTRUCTION, 0,
610 OUT_BCS_BATCH(batch, 0);
611 OUT_BCS_BATCH(batch, 0);
615 /* the current decoding frame/field */
616 va_pic = &pic_param->CurrPic;
617 assert(!(va_pic->flags & VA_PICTURE_H264_INVALID));
618 obj_surface = SURFACE(va_pic->picture_id);
619 assert(obj_surface && obj_surface->bo && obj_surface->private_data);
620 gen7_avc_surface = obj_surface->private_data;
622 OUT_BCS_RELOC(batch, gen7_avc_surface->dmv_top,
623 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
626 if (gen7_avc_surface->dmv_bottom_flag == 1)
627 OUT_BCS_RELOC(batch, gen7_avc_surface->dmv_bottom,
628 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
631 OUT_BCS_RELOC(batch, gen7_avc_surface->dmv_top,
632 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
636 for (i = 0; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++) {
637 if (gen7_mfd_context->reference_surface[i].surface_id != VA_INVALID_ID) {
639 for (j = 0; j < ARRAY_ELEMS(pic_param->ReferenceFrames); j++) {
640 va_pic = &pic_param->ReferenceFrames[j];
642 if (va_pic->flags & VA_PICTURE_H264_INVALID)
645 if (va_pic->picture_id == gen7_mfd_context->reference_surface[i].surface_id) {
652 assert(!(va_pic->flags & VA_PICTURE_H264_INVALID));
654 OUT_BCS_BATCH(batch, va_pic->TopFieldOrderCnt);
655 OUT_BCS_BATCH(batch, va_pic->BottomFieldOrderCnt);
657 OUT_BCS_BATCH(batch, 0);
658 OUT_BCS_BATCH(batch, 0);
662 va_pic = &pic_param->CurrPic;
663 OUT_BCS_BATCH(batch, va_pic->TopFieldOrderCnt);
664 OUT_BCS_BATCH(batch, va_pic->BottomFieldOrderCnt);
666 ADVANCE_BCS_BATCH(batch);
670 gen7_mfd_avc_slice_state(VADriverContextP ctx,
671 VAPictureParameterBufferH264 *pic_param,
672 VASliceParameterBufferH264 *slice_param,
673 VASliceParameterBufferH264 *next_slice_param,
674 struct gen7_mfd_context *gen7_mfd_context)
676 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
677 int width_in_mbs = pic_param->picture_width_in_mbs_minus1 + 1;
678 int height_in_mbs = pic_param->picture_height_in_mbs_minus1 + 1;
679 int slice_hor_pos, slice_ver_pos, next_slice_hor_pos, next_slice_ver_pos;
680 int num_ref_idx_l0, num_ref_idx_l1;
681 int mbaff_picture = (!pic_param->pic_fields.bits.field_pic_flag &&
682 pic_param->seq_fields.bits.mb_adaptive_frame_field_flag);
683 int first_mb_in_slice = 0, first_mb_in_next_slice = 0;
686 if (slice_param->slice_type == SLICE_TYPE_I ||
687 slice_param->slice_type == SLICE_TYPE_SI) {
688 slice_type = SLICE_TYPE_I;
689 } else if (slice_param->slice_type == SLICE_TYPE_P ||
690 slice_param->slice_type == SLICE_TYPE_SP) {
691 slice_type = SLICE_TYPE_P;
693 assert(slice_param->slice_type == SLICE_TYPE_B);
694 slice_type = SLICE_TYPE_B;
697 if (slice_type == SLICE_TYPE_I) {
698 assert(slice_param->num_ref_idx_l0_active_minus1 == 0);
699 assert(slice_param->num_ref_idx_l1_active_minus1 == 0);
702 } else if (slice_type == SLICE_TYPE_P) {
703 assert(slice_param->num_ref_idx_l1_active_minus1 == 0);
704 num_ref_idx_l0 = slice_param->num_ref_idx_l0_active_minus1 + 1;
707 num_ref_idx_l0 = slice_param->num_ref_idx_l0_active_minus1 + 1;
708 num_ref_idx_l1 = slice_param->num_ref_idx_l1_active_minus1 + 1;
711 first_mb_in_slice = slice_param->first_mb_in_slice << mbaff_picture;
712 slice_hor_pos = first_mb_in_slice % width_in_mbs;
713 slice_ver_pos = first_mb_in_slice / width_in_mbs;
715 if (next_slice_param) {
716 first_mb_in_next_slice = next_slice_param->first_mb_in_slice << mbaff_picture;
717 next_slice_hor_pos = first_mb_in_next_slice % width_in_mbs;
718 next_slice_ver_pos = first_mb_in_next_slice / width_in_mbs;
720 next_slice_hor_pos = 0;
721 next_slice_ver_pos = height_in_mbs;
724 BEGIN_BCS_BATCH(batch, 11); /* FIXME: is it 10??? */
725 OUT_BCS_BATCH(batch, MFX_AVC_SLICE_STATE | (11 - 2));
726 OUT_BCS_BATCH(batch, slice_type);
728 (num_ref_idx_l1 << 24) |
729 (num_ref_idx_l0 << 16) |
730 (slice_param->chroma_log2_weight_denom << 8) |
731 (slice_param->luma_log2_weight_denom << 0));
733 (slice_param->direct_spatial_mv_pred_flag << 29) |
734 (slice_param->disable_deblocking_filter_idc << 27) |
735 (slice_param->cabac_init_idc << 24) |
736 ((pic_param->pic_init_qp_minus26 + 26 + slice_param->slice_qp_delta) << 16) |
737 ((slice_param->slice_beta_offset_div2 & 0xf) << 8) |
738 ((slice_param->slice_alpha_c0_offset_div2 & 0xf) << 0));
740 (slice_ver_pos << 24) |
741 (slice_hor_pos << 16) |
742 (first_mb_in_slice << 0));
744 (next_slice_ver_pos << 16) |
745 (next_slice_hor_pos << 0));
747 (next_slice_param == NULL) << 19); /* last slice flag */
748 OUT_BCS_BATCH(batch, 0);
749 OUT_BCS_BATCH(batch, 0);
750 OUT_BCS_BATCH(batch, 0);
751 OUT_BCS_BATCH(batch, 0);
752 ADVANCE_BCS_BATCH(batch);
756 gen7_mfd_avc_ref_idx_state(VADriverContextP ctx,
757 VAPictureParameterBufferH264 *pic_param,
758 VASliceParameterBufferH264 *slice_param,
759 struct gen7_mfd_context *gen7_mfd_context)
761 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
762 int i, j, num_ref_list;
764 unsigned char bottom_idc:1;
765 unsigned char frame_store_index:4;
766 unsigned char field_picture:1;
767 unsigned char long_term:1;
768 unsigned char non_exist:1;
771 if (slice_param->slice_type == SLICE_TYPE_I ||
772 slice_param->slice_type == SLICE_TYPE_SI)
775 if (slice_param->slice_type == SLICE_TYPE_P ||
776 slice_param->slice_type == SLICE_TYPE_SP) {
782 for (i = 0; i < num_ref_list; i++) {
783 VAPictureH264 *va_pic;
786 va_pic = slice_param->RefPicList0;
788 va_pic = slice_param->RefPicList1;
791 BEGIN_BCS_BATCH(batch, 10);
792 OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | (10 - 2));
793 OUT_BCS_BATCH(batch, i);
795 for (j = 0; j < 32; j++) {
796 if (va_pic->flags & VA_PICTURE_H264_INVALID) {
797 refs[j].non_exist = 1;
798 refs[j].long_term = 1;
799 refs[j].field_picture = 1;
800 refs[j].frame_store_index = 0xf;
801 refs[j].bottom_idc = 1;
805 for (frame_idx = 0; frame_idx < ARRAY_ELEMS(gen7_mfd_context->reference_surface); frame_idx++) {
806 if (gen7_mfd_context->reference_surface[frame_idx].surface_id != VA_INVALID_ID &&
807 va_pic->picture_id == gen7_mfd_context->reference_surface[frame_idx].surface_id) {
808 assert(frame_idx == gen7_mfd_context->reference_surface[frame_idx].frame_store_id);
813 assert(frame_idx < ARRAY_ELEMS(gen7_mfd_context->reference_surface));
815 refs[j].non_exist = 0;
816 refs[j].long_term = !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);
817 refs[j].field_picture = !!(va_pic->flags &
818 (VA_PICTURE_H264_TOP_FIELD |
819 VA_PICTURE_H264_BOTTOM_FIELD));
820 refs[j].frame_store_index = frame_idx;
821 refs[j].bottom_idc = !!(va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD);
827 intel_batchbuffer_data(batch, refs, sizeof(refs));
828 ADVANCE_BCS_BATCH(batch);
833 gen7_mfd_avc_weightoffset_state(VADriverContextP ctx,
834 VAPictureParameterBufferH264 *pic_param,
835 VASliceParameterBufferH264 *slice_param,
836 struct gen7_mfd_context *gen7_mfd_context)
838 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
839 int i, j, num_weight_offset_table = 0;
840 short weightoffsets[32 * 6];
842 if ((slice_param->slice_type == SLICE_TYPE_P ||
843 slice_param->slice_type == SLICE_TYPE_SP) &&
844 (pic_param->pic_fields.bits.weighted_pred_flag == 1)) {
845 num_weight_offset_table = 1;
848 if ((slice_param->slice_type == SLICE_TYPE_B) &&
849 (pic_param->pic_fields.bits.weighted_bipred_idc == 1)) {
850 num_weight_offset_table = 2;
853 for (i = 0; i < num_weight_offset_table; i++) {
854 BEGIN_BCS_BATCH(batch, 98);
855 OUT_BCS_BATCH(batch, MFX_AVC_WEIGHTOFFSET_STATE | (98 - 2));
856 OUT_BCS_BATCH(batch, i);
859 for (j = 0; j < 32; j++) {
860 weightoffsets[j * 6 + 0] = slice_param->luma_weight_l0[j];
861 weightoffsets[j * 6 + 1] = slice_param->luma_offset_l0[j];
862 weightoffsets[j * 6 + 2] = slice_param->chroma_weight_l0[j][0];
863 weightoffsets[j * 6 + 3] = slice_param->chroma_offset_l0[j][0];
864 weightoffsets[j * 6 + 4] = slice_param->chroma_weight_l0[j][1];
865 weightoffsets[j * 6 + 5] = slice_param->chroma_offset_l0[j][1];
868 for (j = 0; j < 32; j++) {
869 weightoffsets[j * 6 + 0] = slice_param->luma_weight_l1[j];
870 weightoffsets[j * 6 + 1] = slice_param->luma_offset_l1[j];
871 weightoffsets[j * 6 + 2] = slice_param->chroma_weight_l1[j][0];
872 weightoffsets[j * 6 + 3] = slice_param->chroma_offset_l1[j][0];
873 weightoffsets[j * 6 + 4] = slice_param->chroma_weight_l1[j][1];
874 weightoffsets[j * 6 + 5] = slice_param->chroma_offset_l1[j][1];
878 intel_batchbuffer_data(batch, weightoffsets, sizeof(weightoffsets));
879 ADVANCE_BCS_BATCH(batch);
884 gen7_mfd_avc_get_slice_bit_offset(uint8_t *buf, int mode_flag, int in_slice_data_bit_offset)
886 int out_slice_data_bit_offset;
887 int slice_header_size = in_slice_data_bit_offset / 8;
890 for (i = 0, j = 0; i < slice_header_size; i++, j++) {
891 if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3) {
896 out_slice_data_bit_offset = 8 * j + in_slice_data_bit_offset % 8;
898 if (mode_flag == ENTROPY_CABAC)
899 out_slice_data_bit_offset = ALIGN(out_slice_data_bit_offset, 0x8);
901 return out_slice_data_bit_offset;
905 gen7_mfd_avc_bsd_object(VADriverContextP ctx,
906 VAPictureParameterBufferH264 *pic_param,
907 VASliceParameterBufferH264 *slice_param,
908 dri_bo *slice_data_bo,
909 VASliceParameterBufferH264 *next_slice_param,
910 struct gen7_mfd_context *gen7_mfd_context)
912 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
913 int slice_data_bit_offset;
914 uint8_t *slice_data = NULL;
916 dri_bo_map(slice_data_bo, 0);
917 slice_data = (uint8_t *)(slice_data_bo->virtual + slice_param->slice_data_offset);
918 slice_data_bit_offset = gen7_mfd_avc_get_slice_bit_offset(slice_data,
919 pic_param->pic_fields.bits.entropy_coding_mode_flag,
920 slice_param->slice_data_bit_offset);
921 dri_bo_unmap(slice_data_bo);
923 /* the input bitsteam format on GEN7 differs from GEN6 */
924 BEGIN_BCS_BATCH(batch, 6);
925 OUT_BCS_BATCH(batch, MFD_AVC_BSD_OBJECT | (6 - 2));
927 (slice_param->slice_data_size));
928 OUT_BCS_BATCH(batch, slice_param->slice_data_offset);
936 ((slice_data_bit_offset >> 3) << 16) |
939 ((next_slice_param == NULL) << 3) | /* LastSlice Flag */
940 (slice_data_bit_offset & 0x7));
941 OUT_BCS_BATCH(batch, 0);
942 ADVANCE_BCS_BATCH(batch);
946 gen7_mfd_avc_decode_init(VADriverContextP ctx,
947 struct decode_state *decode_state,
948 struct gen7_mfd_context *gen7_mfd_context)
950 VAPictureParameterBufferH264 *pic_param;
951 VASliceParameterBufferH264 *slice_param;
952 VAPictureH264 *va_pic;
953 struct i965_driver_data *i965 = i965_driver_data(ctx);
954 struct object_surface *obj_surface;
956 int i, j, enable_avc_ildb = 0;
958 for (j = 0; j < decode_state->num_slice_params && enable_avc_ildb == 0; j++) {
959 assert(decode_state->slice_params && decode_state->slice_params[j]->buffer);
960 slice_param = (VASliceParameterBufferH264 *)decode_state->slice_params[j]->buffer;
962 assert(decode_state->slice_params[j]->num_elements == 1);
963 for (i = 0; i < decode_state->slice_params[j]->num_elements; i++) {
964 assert(slice_param->slice_data_flag == VA_SLICE_DATA_FLAG_ALL);
965 assert((slice_param->slice_type == SLICE_TYPE_I) ||
966 (slice_param->slice_type == SLICE_TYPE_SI) ||
967 (slice_param->slice_type == SLICE_TYPE_P) ||
968 (slice_param->slice_type == SLICE_TYPE_SP) ||
969 (slice_param->slice_type == SLICE_TYPE_B));
971 if (slice_param->disable_deblocking_filter_idc != 1) {
980 assert(decode_state->pic_param && decode_state->pic_param->buffer);
981 pic_param = (VAPictureParameterBufferH264 *)decode_state->pic_param->buffer;
982 gen7_mfd_avc_frame_store_index(ctx, pic_param, gen7_mfd_context);
984 /* Current decoded picture */
985 va_pic = &pic_param->CurrPic;
986 assert(!(va_pic->flags & VA_PICTURE_H264_INVALID));
987 obj_surface = SURFACE(va_pic->picture_id);
989 obj_surface->flags &= ~SURFACE_REF_DIS_MASK;
990 obj_surface->flags |= (pic_param->pic_fields.bits.reference_pic_flag ? SURFACE_REFERENCED : 0);
991 gen7_mfd_init_avc_surface(ctx, pic_param, obj_surface);
992 i965_check_alloc_surface_bo(ctx, obj_surface, 1);
994 dri_bo_unreference(gen7_mfd_context->post_deblocking_output.bo);
995 gen7_mfd_context->post_deblocking_output.bo = obj_surface->bo;
996 dri_bo_reference(gen7_mfd_context->post_deblocking_output.bo);
997 gen7_mfd_context->post_deblocking_output.valid = enable_avc_ildb;
999 dri_bo_unreference(gen7_mfd_context->pre_deblocking_output.bo);
1000 gen7_mfd_context->pre_deblocking_output.bo = obj_surface->bo;
1001 dri_bo_reference(gen7_mfd_context->pre_deblocking_output.bo);
1002 gen7_mfd_context->pre_deblocking_output.valid = !enable_avc_ildb;
1004 dri_bo_unreference(gen7_mfd_context->intra_row_store_scratch_buffer.bo);
1005 bo = dri_bo_alloc(i965->intel.bufmgr,
1010 gen7_mfd_context->intra_row_store_scratch_buffer.bo = bo;
1011 gen7_mfd_context->intra_row_store_scratch_buffer.valid = 1;
1013 dri_bo_unreference(gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo);
1014 bo = dri_bo_alloc(i965->intel.bufmgr,
1015 "deblocking filter row store",
1016 30720, /* 4 * 120 * 64 */
1019 gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo = bo;
1020 gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.valid = 1;
1022 dri_bo_unreference(gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo);
1023 bo = dri_bo_alloc(i965->intel.bufmgr,
1024 "bsd mpc row store",
1025 11520, /* 1.5 * 120 * 64 */
1028 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo = bo;
1029 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.valid = 1;
1031 dri_bo_unreference(gen7_mfd_context->mpr_row_store_scratch_buffer.bo);
1032 bo = dri_bo_alloc(i965->intel.bufmgr,
1034 7680, /* 1. 0 * 120 * 64 */
1037 gen7_mfd_context->mpr_row_store_scratch_buffer.bo = bo;
1038 gen7_mfd_context->mpr_row_store_scratch_buffer.valid = 1;
1040 gen7_mfd_context->bitplane_read_buffer.valid = 0;
1044 gen7_mfd_avc_decode_picture(VADriverContextP ctx,
1045 struct decode_state *decode_state,
1046 struct gen7_mfd_context *gen7_mfd_context)
1048 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1049 VAPictureParameterBufferH264 *pic_param;
1050 VASliceParameterBufferH264 *slice_param, *next_slice_param;
1051 dri_bo *slice_data_bo;
1054 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1055 pic_param = (VAPictureParameterBufferH264 *)decode_state->pic_param->buffer;
1056 gen7_mfd_avc_decode_init(ctx, decode_state, gen7_mfd_context);
1058 intel_batchbuffer_start_atomic_bcs(batch, 0x1000);
1059 intel_batchbuffer_emit_mi_flush(batch);
1060 gen7_mfd_pipe_mode_select(ctx, decode_state, MFX_FORMAT_AVC, gen7_mfd_context);
1061 gen7_mfd_surface_state(ctx, decode_state, MFX_FORMAT_AVC, gen7_mfd_context);
1062 gen7_mfd_pipe_buf_addr_state(ctx, decode_state, MFX_FORMAT_AVC, gen7_mfd_context);
1063 gen7_mfd_bsp_buf_base_addr_state(ctx, decode_state, MFX_FORMAT_AVC, gen7_mfd_context);
1064 gen7_mfd_avc_qm_state(ctx, decode_state, gen7_mfd_context);
1065 gen7_mfd_avc_img_state(ctx, decode_state, gen7_mfd_context);
1067 for (j = 0; j < decode_state->num_slice_params; j++) {
1068 assert(decode_state->slice_params && decode_state->slice_params[j]->buffer);
1069 slice_param = (VASliceParameterBufferH264 *)decode_state->slice_params[j]->buffer;
1070 slice_data_bo = decode_state->slice_datas[j]->bo;
1072 if (j == decode_state->num_slice_params - 1)
1073 next_slice_param = NULL;
1075 next_slice_param = (VASliceParameterBufferH264 *)decode_state->slice_params[j + 1]->buffer;
1077 gen7_mfd_ind_obj_base_addr_state(ctx, slice_data_bo, MFX_FORMAT_AVC, gen7_mfd_context);
1078 assert(decode_state->slice_params[j]->num_elements == 1);
1080 for (i = 0; i < decode_state->slice_params[j]->num_elements; i++) {
1081 assert(slice_param->slice_data_flag == VA_SLICE_DATA_FLAG_ALL);
1082 assert((slice_param->slice_type == SLICE_TYPE_I) ||
1083 (slice_param->slice_type == SLICE_TYPE_SI) ||
1084 (slice_param->slice_type == SLICE_TYPE_P) ||
1085 (slice_param->slice_type == SLICE_TYPE_SP) ||
1086 (slice_param->slice_type == SLICE_TYPE_B));
1088 if (i < decode_state->slice_params[j]->num_elements - 1)
1089 next_slice_param = slice_param + 1;
1091 gen7_mfd_avc_directmode_state(ctx, pic_param, slice_param, gen7_mfd_context);
1092 gen7_mfd_avc_ref_idx_state(ctx, pic_param, slice_param, gen7_mfd_context);
1093 gen7_mfd_avc_weightoffset_state(ctx, pic_param, slice_param, gen7_mfd_context);
1094 gen7_mfd_avc_slice_state(ctx, pic_param, slice_param, next_slice_param, gen7_mfd_context);
1095 gen7_mfd_avc_bsd_object(ctx, pic_param, slice_param, slice_data_bo, next_slice_param, gen7_mfd_context);
1100 intel_batchbuffer_end_atomic(batch);
1101 intel_batchbuffer_flush(batch);
1105 gen7_mfd_mpeg2_decode_init(VADriverContextP ctx,
1106 struct decode_state *decode_state,
1107 struct gen7_mfd_context *gen7_mfd_context)
1109 VAPictureParameterBufferMPEG2 *pic_param;
1110 struct i965_driver_data *i965 = i965_driver_data(ctx);
1111 struct object_surface *obj_surface;
1115 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1116 pic_param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
1118 /* reference picture */
1119 obj_surface = SURFACE(pic_param->forward_reference_picture);
1121 if (obj_surface && obj_surface->bo)
1122 gen7_mfd_context->reference_surface[0].surface_id = pic_param->forward_reference_picture;
1124 gen7_mfd_context->reference_surface[0].surface_id = VA_INVALID_ID;
1126 obj_surface = SURFACE(pic_param->backward_reference_picture);
1128 if (obj_surface && obj_surface->bo)
1129 gen7_mfd_context->reference_surface[1].surface_id = pic_param->backward_reference_picture;
1131 gen7_mfd_context->reference_surface[1].surface_id = pic_param->forward_reference_picture;
1133 /* must do so !!! */
1134 for (i = 2; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++)
1135 gen7_mfd_context->reference_surface[i].surface_id = gen7_mfd_context->reference_surface[i % 2].surface_id;
1137 /* Current decoded picture */
1138 obj_surface = SURFACE(decode_state->current_render_target);
1139 assert(obj_surface);
1140 i965_check_alloc_surface_bo(ctx, obj_surface, 1);
1142 dri_bo_unreference(gen7_mfd_context->pre_deblocking_output.bo);
1143 gen7_mfd_context->pre_deblocking_output.bo = obj_surface->bo;
1144 dri_bo_reference(gen7_mfd_context->pre_deblocking_output.bo);
1145 gen7_mfd_context->pre_deblocking_output.valid = 1;
1147 dri_bo_unreference(gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo);
1148 bo = dri_bo_alloc(i965->intel.bufmgr,
1149 "bsd mpc row store",
1150 11520, /* 1.5 * 120 * 64 */
1153 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo = bo;
1154 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.valid = 1;
1156 gen7_mfd_context->post_deblocking_output.valid = 0;
1157 gen7_mfd_context->intra_row_store_scratch_buffer.valid = 0;
1158 gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.valid = 0;
1159 gen7_mfd_context->mpr_row_store_scratch_buffer.valid = 0;
1160 gen7_mfd_context->bitplane_read_buffer.valid = 0;
1164 gen7_mfd_mpeg2_pic_state(VADriverContextP ctx,
1165 struct decode_state *decode_state,
1166 struct gen7_mfd_context *gen7_mfd_context)
1168 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1169 VAPictureParameterBufferMPEG2 *pic_param;
1171 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1172 pic_param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
1174 BEGIN_BCS_BATCH(batch, 13);
1175 OUT_BCS_BATCH(batch, MFX_MPEG2_PIC_STATE | (13 - 2));
1176 OUT_BCS_BATCH(batch,
1177 (pic_param->f_code & 0xf) << 28 | /* f_code[1][1] */
1178 ((pic_param->f_code >> 4) & 0xf) << 24 | /* f_code[1][0] */
1179 ((pic_param->f_code >> 8) & 0xf) << 20 | /* f_code[0][1] */
1180 ((pic_param->f_code >> 12) & 0xf) << 16 | /* f_code[0][0] */
1181 pic_param->picture_coding_extension.bits.intra_dc_precision << 14 |
1182 pic_param->picture_coding_extension.bits.picture_structure << 12 |
1183 pic_param->picture_coding_extension.bits.top_field_first << 11 |
1184 pic_param->picture_coding_extension.bits.frame_pred_frame_dct << 10 |
1185 pic_param->picture_coding_extension.bits.concealment_motion_vectors << 9 |
1186 pic_param->picture_coding_extension.bits.q_scale_type << 8 |
1187 pic_param->picture_coding_extension.bits.intra_vlc_format << 7 |
1188 pic_param->picture_coding_extension.bits.alternate_scan << 6);
1189 OUT_BCS_BATCH(batch,
1190 pic_param->picture_coding_type << 9);
1191 OUT_BCS_BATCH(batch,
1192 ((ALIGN(pic_param->vertical_size, 16) / 16) - 1) << 16 |
1193 ((ALIGN(pic_param->horizontal_size, 16) / 16) - 1));
1194 OUT_BCS_BATCH(batch, 0);
1195 OUT_BCS_BATCH(batch, 0);
1196 OUT_BCS_BATCH(batch, 0);
1197 OUT_BCS_BATCH(batch, 0);
1198 OUT_BCS_BATCH(batch, 0);
1199 OUT_BCS_BATCH(batch, 0);
1200 OUT_BCS_BATCH(batch, 0);
1201 OUT_BCS_BATCH(batch, 0);
1202 OUT_BCS_BATCH(batch, 0);
1203 ADVANCE_BCS_BATCH(batch);
1207 gen7_mfd_mpeg2_qm_state(VADriverContextP ctx,
1208 struct decode_state *decode_state,
1209 struct gen7_mfd_context *gen7_mfd_context)
1211 VAIQMatrixBufferMPEG2 *iq_matrix;
1214 if (!decode_state->iq_matrix || !decode_state->iq_matrix->buffer)
1217 iq_matrix = (VAIQMatrixBufferMPEG2 *)decode_state->iq_matrix->buffer;
1219 for (i = 0; i < 2; i++) {
1221 unsigned char *qm = NULL;
1222 unsigned char qmx[64];
1226 if (iq_matrix->load_intra_quantiser_matrix) {
1227 qm = iq_matrix->intra_quantiser_matrix;
1228 qm_type = MFX_QM_MPEG_INTRA_QUANTIZER_MATRIX;
1231 if (iq_matrix->load_non_intra_quantiser_matrix) {
1232 qm = iq_matrix->non_intra_quantiser_matrix;
1233 qm_type = MFX_QM_MPEG_NON_INTRA_QUANTIZER_MATRIX;
1240 /* Upload quantisation matrix in raster order. The mplayer vaapi
1241 * patch passes quantisation matrix in zig-zag order to va library.
1243 for (k = 0; k < 64; k++) {
1244 m = zigzag_direct[k];
1248 gen7_mfd_qm_state(ctx, qm_type, qmx, 64, gen7_mfd_context);
1253 gen7_mfd_mpeg2_bsd_object(VADriverContextP ctx,
1254 VAPictureParameterBufferMPEG2 *pic_param,
1255 VASliceParameterBufferMPEG2 *slice_param,
1256 VASliceParameterBufferMPEG2 *next_slice_param,
1257 struct gen7_mfd_context *gen7_mfd_context)
1259 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1260 unsigned int width_in_mbs = ALIGN(pic_param->horizontal_size, 16) / 16;
1261 unsigned int height_in_mbs = ALIGN(pic_param->vertical_size, 16) / 16;
1264 if (next_slice_param == NULL)
1265 mb_count = width_in_mbs * height_in_mbs -
1266 (slice_param->slice_vertical_position * width_in_mbs + slice_param->slice_horizontal_position);
1268 mb_count = (next_slice_param->slice_vertical_position * width_in_mbs + next_slice_param->slice_horizontal_position) -
1269 (slice_param->slice_vertical_position * width_in_mbs + slice_param->slice_horizontal_position);
1271 BEGIN_BCS_BATCH(batch, 5);
1272 OUT_BCS_BATCH(batch, MFD_MPEG2_BSD_OBJECT | (5 - 2));
1273 OUT_BCS_BATCH(batch,
1274 slice_param->slice_data_size - (slice_param->macroblock_offset >> 3));
1275 OUT_BCS_BATCH(batch,
1276 slice_param->slice_data_offset + (slice_param->macroblock_offset >> 3));
1277 OUT_BCS_BATCH(batch,
1278 slice_param->slice_horizontal_position << 24 |
1279 slice_param->slice_vertical_position << 16 |
1281 (next_slice_param == NULL) << 5 |
1282 (next_slice_param == NULL) << 3 |
1283 (slice_param->macroblock_offset & 0x7));
1284 OUT_BCS_BATCH(batch,
1285 slice_param->quantiser_scale_code << 24);
1286 ADVANCE_BCS_BATCH(batch);
1290 gen7_mfd_mpeg2_decode_picture(VADriverContextP ctx,
1291 struct decode_state *decode_state,
1292 struct gen7_mfd_context *gen7_mfd_context)
1294 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1295 VAPictureParameterBufferMPEG2 *pic_param;
1296 VASliceParameterBufferMPEG2 *slice_param, *next_slice_param;
1297 dri_bo *slice_data_bo;
1300 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1301 pic_param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
1303 gen7_mfd_mpeg2_decode_init(ctx, decode_state, gen7_mfd_context);
1304 intel_batchbuffer_start_atomic_bcs(batch, 0x1000);
1305 intel_batchbuffer_emit_mi_flush(batch);
1306 gen7_mfd_pipe_mode_select(ctx, decode_state, MFX_FORMAT_MPEG2, gen7_mfd_context);
1307 gen7_mfd_surface_state(ctx, decode_state, MFX_FORMAT_MPEG2, gen7_mfd_context);
1308 gen7_mfd_pipe_buf_addr_state(ctx, decode_state, MFX_FORMAT_MPEG2, gen7_mfd_context);
1309 gen7_mfd_bsp_buf_base_addr_state(ctx, decode_state, MFX_FORMAT_MPEG2, gen7_mfd_context);
1310 gen7_mfd_mpeg2_pic_state(ctx, decode_state, gen7_mfd_context);
1311 gen7_mfd_mpeg2_qm_state(ctx, decode_state, gen7_mfd_context);
1313 assert(decode_state->num_slice_params == 1);
1314 for (j = 0; j < decode_state->num_slice_params; j++) {
1315 assert(decode_state->slice_params && decode_state->slice_params[j]->buffer);
1316 slice_param = (VASliceParameterBufferMPEG2 *)decode_state->slice_params[j]->buffer;
1317 slice_data_bo = decode_state->slice_datas[j]->bo;
1318 gen7_mfd_ind_obj_base_addr_state(ctx, slice_data_bo, MFX_FORMAT_MPEG2, gen7_mfd_context);
1320 for (i = 0; i < decode_state->slice_params[j]->num_elements; i++) {
1321 assert(slice_param->slice_data_flag == VA_SLICE_DATA_FLAG_ALL);
1323 if (i < decode_state->slice_params[j]->num_elements - 1)
1324 next_slice_param = slice_param + 1;
1326 next_slice_param = NULL;
1328 gen7_mfd_mpeg2_bsd_object(ctx, pic_param, slice_param, next_slice_param, gen7_mfd_context);
1333 intel_batchbuffer_end_atomic(batch);
1334 intel_batchbuffer_flush(batch);
1337 static const int va_to_gen7_vc1_pic_type[5] = {
1341 GEN7_VC1_BI_PICTURE,
1345 static const int va_to_gen7_vc1_mv[4] = {
1347 2, /* 1-MV half-pel */
1348 3, /* 1-MV half-pef bilinear */
1352 static const int b_picture_scale_factor[21] = {
1353 128, 85, 170, 64, 192,
1354 51, 102, 153, 204, 43,
1355 215, 37, 74, 111, 148,
1356 185, 222, 32, 96, 160,
1360 static const int va_to_gen7_vc1_condover[3] = {
1366 static const int va_to_gen7_vc1_profile[4] = {
1367 GEN7_VC1_SIMPLE_PROFILE,
1368 GEN7_VC1_MAIN_PROFILE,
1369 GEN7_VC1_RESERVED_PROFILE,
1370 GEN7_VC1_ADVANCED_PROFILE
1373 static const int va_to_gen7_vc1_ttfrm[8] = {
1385 gen7_mfd_free_vc1_surface(void **data)
1387 struct gen7_vc1_surface *gen7_vc1_surface = *data;
1389 if (!gen7_vc1_surface)
1392 dri_bo_unreference(gen7_vc1_surface->dmv);
1393 free(gen7_vc1_surface);
1398 gen7_mfd_init_vc1_surface(VADriverContextP ctx,
1399 VAPictureParameterBufferVC1 *pic_param,
1400 struct object_surface *obj_surface)
1402 struct i965_driver_data *i965 = i965_driver_data(ctx);
1403 struct gen7_vc1_surface *gen7_vc1_surface = obj_surface->private_data;
1405 obj_surface->free_private_data = gen7_mfd_free_vc1_surface;
1407 if (!gen7_vc1_surface) {
1408 gen7_vc1_surface = calloc(sizeof(struct gen7_vc1_surface), 1);
1409 assert((obj_surface->size & 0x3f) == 0);
1410 obj_surface->private_data = gen7_vc1_surface;
1413 gen7_vc1_surface->picture_type = pic_param->picture_fields.bits.picture_type;
1415 if (gen7_vc1_surface->dmv == NULL) {
1416 gen7_vc1_surface->dmv = dri_bo_alloc(i965->intel.bufmgr,
1417 "direct mv w/r buffer",
1418 557056, /* 64 * 128 * 64 */
1424 gen7_mfd_vc1_decode_init(VADriverContextP ctx,
1425 struct decode_state *decode_state,
1426 struct gen7_mfd_context *gen7_mfd_context)
1428 VAPictureParameterBufferVC1 *pic_param;
1429 struct i965_driver_data *i965 = i965_driver_data(ctx);
1430 struct object_surface *obj_surface;
1434 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1435 pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
1437 /* reference picture */
1438 obj_surface = SURFACE(pic_param->forward_reference_picture);
1440 if (obj_surface && obj_surface->bo)
1441 gen7_mfd_context->reference_surface[0].surface_id = pic_param->forward_reference_picture;
1443 gen7_mfd_context->reference_surface[0].surface_id = VA_INVALID_ID;
1445 obj_surface = SURFACE(pic_param->backward_reference_picture);
1447 if (obj_surface && obj_surface->bo)
1448 gen7_mfd_context->reference_surface[1].surface_id = pic_param->backward_reference_picture;
1450 gen7_mfd_context->reference_surface[1].surface_id = pic_param->forward_reference_picture;
1452 /* must do so !!! */
1453 for (i = 2; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++)
1454 gen7_mfd_context->reference_surface[i].surface_id = gen7_mfd_context->reference_surface[i % 2].surface_id;
1456 /* Current decoded picture */
1457 obj_surface = SURFACE(decode_state->current_render_target);
1458 assert(obj_surface);
1459 gen7_mfd_init_vc1_surface(ctx, pic_param, obj_surface);
1460 i965_check_alloc_surface_bo(ctx, obj_surface, 1);
1462 dri_bo_unreference(gen7_mfd_context->post_deblocking_output.bo);
1463 gen7_mfd_context->post_deblocking_output.bo = obj_surface->bo;
1464 dri_bo_reference(gen7_mfd_context->post_deblocking_output.bo);
1465 gen7_mfd_context->post_deblocking_output.valid = pic_param->entrypoint_fields.bits.loopfilter;
1467 dri_bo_unreference(gen7_mfd_context->pre_deblocking_output.bo);
1468 gen7_mfd_context->pre_deblocking_output.bo = obj_surface->bo;
1469 dri_bo_reference(gen7_mfd_context->pre_deblocking_output.bo);
1470 gen7_mfd_context->pre_deblocking_output.valid = !pic_param->entrypoint_fields.bits.loopfilter;
1472 dri_bo_unreference(gen7_mfd_context->intra_row_store_scratch_buffer.bo);
1473 bo = dri_bo_alloc(i965->intel.bufmgr,
1478 gen7_mfd_context->intra_row_store_scratch_buffer.bo = bo;
1479 gen7_mfd_context->intra_row_store_scratch_buffer.valid = 1;
1481 dri_bo_unreference(gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo);
1482 bo = dri_bo_alloc(i965->intel.bufmgr,
1483 "deblocking filter row store",
1484 46080, /* 6 * 120 * 64 */
1487 gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo = bo;
1488 gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.valid = 1;
1490 dri_bo_unreference(gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo);
1491 bo = dri_bo_alloc(i965->intel.bufmgr,
1492 "bsd mpc row store",
1493 11520, /* 1.5 * 120 * 64 */
1496 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo = bo;
1497 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.valid = 1;
1499 gen7_mfd_context->mpr_row_store_scratch_buffer.valid = 0;
1501 gen7_mfd_context->bitplane_read_buffer.valid = !!pic_param->bitplane_present.value;
1502 dri_bo_unreference(gen7_mfd_context->bitplane_read_buffer.bo);
1504 if (gen7_mfd_context->bitplane_read_buffer.valid) {
1505 int width_in_mbs = ALIGN(pic_param->coded_width, 16) / 16;
1506 int height_in_mbs = ALIGN(pic_param->coded_height, 16) / 16;
1507 int bitplane_width = ALIGN(width_in_mbs, 2) / 2;
1509 uint8_t *src = NULL, *dst = NULL;
1511 assert(decode_state->bit_plane->buffer);
1512 src = decode_state->bit_plane->buffer;
1514 bo = dri_bo_alloc(i965->intel.bufmgr,
1516 bitplane_width * bitplane_width,
1519 gen7_mfd_context->bitplane_read_buffer.bo = bo;
1521 dri_bo_map(bo, True);
1522 assert(bo->virtual);
1525 for (src_h = 0; src_h < height_in_mbs; src_h++) {
1526 for(src_w = 0; src_w < width_in_mbs; src_w++) {
1527 int src_index, dst_index;
1531 src_index = (src_h * width_in_mbs + src_w) / 2;
1532 src_shift = !((src_h * width_in_mbs + src_w) & 1) * 4;
1533 src_value = ((src[src_index] >> src_shift) & 0xf);
1535 dst_index = src_w / 2;
1536 dst[dst_index] = ((dst[dst_index] >> 4) | (src_value << 4));
1540 dst[src_w / 2] >>= 4;
1542 dst += bitplane_width;
1547 gen7_mfd_context->bitplane_read_buffer.bo = NULL;
1551 gen7_mfd_vc1_pic_state(VADriverContextP ctx,
1552 struct decode_state *decode_state,
1553 struct gen7_mfd_context *gen7_mfd_context)
1555 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1556 VAPictureParameterBufferVC1 *pic_param;
1557 struct i965_driver_data *i965 = i965_driver_data(ctx);
1558 struct object_surface *obj_surface;
1559 int alt_pquant_config = 0, alt_pquant_edge_mask = 0, alt_pq;
1560 int dquant, dquantfrm, dqprofile, dqdbedge, dqsbedge, dqbilevel;
1561 int unified_mv_mode;
1562 int ref_field_pic_polarity = 0;
1563 int scale_factor = 0;
1565 int dmv_surface_valid = 0;
1571 int interpolation_mode = 0;
1573 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1574 pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
1576 profile = va_to_gen7_vc1_profile[pic_param->sequence_fields.bits.profile];
1577 dquant = pic_param->pic_quantizer_fields.bits.dquant;
1578 dquantfrm = pic_param->pic_quantizer_fields.bits.dq_frame;
1579 dqprofile = pic_param->pic_quantizer_fields.bits.dq_profile;
1580 dqdbedge = pic_param->pic_quantizer_fields.bits.dq_db_edge;
1581 dqsbedge = pic_param->pic_quantizer_fields.bits.dq_sb_edge;
1582 dqbilevel = pic_param->pic_quantizer_fields.bits.dq_binary_level;
1583 alt_pq = pic_param->pic_quantizer_fields.bits.alt_pic_quantizer;
1586 alt_pquant_config = 0;
1587 alt_pquant_edge_mask = 0;
1588 } else if (dquant == 2) {
1589 alt_pquant_config = 1;
1590 alt_pquant_edge_mask = 0xf;
1592 assert(dquant == 1);
1593 if (dquantfrm == 0) {
1594 alt_pquant_config = 0;
1595 alt_pquant_edge_mask = 0;
1598 assert(dquantfrm == 1);
1599 alt_pquant_config = 1;
1601 switch (dqprofile) {
1603 if (dqbilevel == 0) {
1604 alt_pquant_config = 2;
1605 alt_pquant_edge_mask = 0;
1607 assert(dqbilevel == 1);
1608 alt_pquant_config = 3;
1609 alt_pquant_edge_mask = 0;
1614 alt_pquant_edge_mask = 0xf;
1619 alt_pquant_edge_mask = 0x9;
1621 alt_pquant_edge_mask = (0x3 << dqdbedge);
1626 alt_pquant_edge_mask = (0x1 << dqsbedge);
1635 if (pic_param->mv_fields.bits.mv_mode == VAMvModeIntensityCompensation) {
1636 assert(pic_param->mv_fields.bits.mv_mode2 < 4);
1637 unified_mv_mode = va_to_gen7_vc1_mv[pic_param->mv_fields.bits.mv_mode2];
1639 assert(pic_param->mv_fields.bits.mv_mode < 4);
1640 unified_mv_mode = va_to_gen7_vc1_mv[pic_param->mv_fields.bits.mv_mode];
1643 if (pic_param->sequence_fields.bits.interlace == 1 &&
1644 pic_param->picture_fields.bits.frame_coding_mode != 0) { /* frame-interlace or field-interlace */
1645 /* FIXME: calculate reference field picture polarity */
1647 ref_field_pic_polarity = 0;
1650 if (pic_param->b_picture_fraction < 21)
1651 scale_factor = b_picture_scale_factor[pic_param->b_picture_fraction];
1653 picture_type = va_to_gen7_vc1_pic_type[pic_param->picture_fields.bits.picture_type];
1655 if (profile == GEN7_VC1_ADVANCED_PROFILE &&
1656 picture_type == GEN7_VC1_I_PICTURE)
1657 picture_type = GEN7_VC1_BI_PICTURE;
1659 if (picture_type == GEN7_VC1_I_PICTURE || picture_type == GEN7_VC1_BI_PICTURE) /* I picture */
1660 trans_ac_y = pic_param->transform_fields.bits.transform_ac_codingset_idx2;
1662 trans_ac_y = pic_param->transform_fields.bits.transform_ac_codingset_idx1;
1665 if (picture_type == GEN7_VC1_B_PICTURE) {
1666 struct gen7_vc1_surface *gen7_vc1_surface = NULL;
1668 obj_surface = SURFACE(pic_param->backward_reference_picture);
1669 assert(obj_surface);
1670 gen7_vc1_surface = obj_surface->private_data;
1672 if (!gen7_vc1_surface ||
1673 (va_to_gen7_vc1_pic_type[gen7_vc1_surface->picture_type] == GEN7_VC1_I_PICTURE ||
1674 va_to_gen7_vc1_pic_type[gen7_vc1_surface->picture_type] == GEN7_VC1_BI_PICTURE))
1675 dmv_surface_valid = 0;
1677 dmv_surface_valid = 1;
1680 assert(pic_param->picture_fields.bits.frame_coding_mode < 3);
1682 if (pic_param->picture_fields.bits.frame_coding_mode < 2)
1683 fcm = pic_param->picture_fields.bits.frame_coding_mode;
1685 if (pic_param->picture_fields.bits.top_field_first)
1691 if (pic_param->picture_fields.bits.picture_type == GEN7_VC1_B_PICTURE) { /* B picture */
1692 brfd = pic_param->reference_fields.bits.reference_distance;
1693 brfd = (scale_factor * brfd) >> 8;
1694 brfd = pic_param->reference_fields.bits.reference_distance - brfd - 1;
1700 overlap = pic_param->sequence_fields.bits.overlap;
1701 if (profile != GEN7_VC1_ADVANCED_PROFILE && pic_param->pic_quantizer_fields.bits.pic_quantizer_scale < 9)
1704 assert(pic_param->conditional_overlap_flag < 3);
1705 assert(pic_param->mv_fields.bits.mv_table < 4); /* FIXME: interlace mode */
1707 if (pic_param->mv_fields.bits.mv_mode == VAMvMode1MvHalfPelBilinear ||
1708 (pic_param->mv_fields.bits.mv_mode == VAMvModeIntensityCompensation &&
1709 pic_param->mv_fields.bits.mv_mode2 == VAMvMode1MvHalfPelBilinear))
1710 interpolation_mode = 8; /* Half-pel bilinear */
1711 else if (pic_param->mv_fields.bits.mv_mode == VAMvMode1MvHalfPel ||
1712 (pic_param->mv_fields.bits.mv_mode == VAMvModeIntensityCompensation &&
1713 pic_param->mv_fields.bits.mv_mode2 == VAMvMode1MvHalfPel))
1714 interpolation_mode = 0; /* Half-pel bicubic */
1716 interpolation_mode = 1; /* Quarter-pel bicubic */
1718 BEGIN_BCS_BATCH(batch, 6);
1719 OUT_BCS_BATCH(batch, MFD_VC1_LONG_PIC_STATE | (6 - 2));
1720 OUT_BCS_BATCH(batch,
1721 (((ALIGN(pic_param->coded_height, 16) / 16) - 1) << 16) |
1722 ((ALIGN(pic_param->coded_width, 16) / 16) - 1));
1723 OUT_BCS_BATCH(batch,
1724 ((ALIGN(pic_param->coded_width, 16) / 16 + 1) / 2 - 1) << 24 |
1725 dmv_surface_valid << 15 |
1726 (pic_param->pic_quantizer_fields.bits.quantizer == 0) << 14 | /* implicit quantizer */
1727 pic_param->rounding_control << 13 |
1728 pic_param->sequence_fields.bits.syncmarker << 12 |
1729 interpolation_mode << 8 |
1730 0 << 7 | /* FIXME: scale up or down ??? */
1731 pic_param->range_reduction_frame << 6 |
1732 pic_param->entrypoint_fields.bits.loopfilter << 5 |
1734 !pic_param->picture_fields.bits.is_first_field << 3 |
1735 (pic_param->sequence_fields.bits.profile == 3) << 0);
1736 OUT_BCS_BATCH(batch,
1737 va_to_gen7_vc1_condover[pic_param->conditional_overlap_flag] << 29 |
1738 picture_type << 26 |
1741 pic_param->pic_quantizer_fields.bits.pic_quantizer_scale << 8 |
1743 OUT_BCS_BATCH(batch,
1744 unified_mv_mode << 28 |
1745 pic_param->mv_fields.bits.four_mv_switch << 27 |
1746 pic_param->fast_uvmc_flag << 26 |
1747 ref_field_pic_polarity << 25 |
1748 pic_param->reference_fields.bits.num_reference_pictures << 24 |
1749 pic_param->reference_fields.bits.reference_distance << 20 |
1750 pic_param->reference_fields.bits.reference_distance << 16 | /* FIXME: ??? */
1751 pic_param->mv_fields.bits.extended_dmv_range << 10 |
1752 pic_param->mv_fields.bits.extended_mv_range << 8 |
1753 alt_pquant_edge_mask << 4 |
1754 alt_pquant_config << 2 |
1755 pic_param->pic_quantizer_fields.bits.half_qp << 1 |
1756 pic_param->pic_quantizer_fields.bits.pic_quantizer_type << 0);
1757 OUT_BCS_BATCH(batch,
1758 !!pic_param->bitplane_present.value << 31 |
1759 !pic_param->bitplane_present.flags.bp_forward_mb << 30 |
1760 !pic_param->bitplane_present.flags.bp_mv_type_mb << 29 |
1761 !pic_param->bitplane_present.flags.bp_skip_mb << 28 |
1762 !pic_param->bitplane_present.flags.bp_direct_mb << 27 |
1763 !pic_param->bitplane_present.flags.bp_overflags << 26 |
1764 !pic_param->bitplane_present.flags.bp_ac_pred << 25 |
1765 !pic_param->bitplane_present.flags.bp_field_tx << 24 |
1766 pic_param->mv_fields.bits.mv_table << 20 |
1767 pic_param->mv_fields.bits.four_mv_block_pattern_table << 18 |
1768 pic_param->mv_fields.bits.two_mv_block_pattern_table << 16 |
1769 va_to_gen7_vc1_ttfrm[pic_param->transform_fields.bits.frame_level_transform_type] << 12 |
1770 pic_param->transform_fields.bits.mb_level_transform_type_flag << 11 |
1771 pic_param->mb_mode_table << 8 |
1773 pic_param->transform_fields.bits.transform_ac_codingset_idx1 << 4 |
1774 pic_param->transform_fields.bits.intra_transform_dc_table << 3 |
1775 pic_param->cbp_table << 0);
1776 ADVANCE_BCS_BATCH(batch);
1780 gen7_mfd_vc1_pred_pipe_state(VADriverContextP ctx,
1781 struct decode_state *decode_state,
1782 struct gen7_mfd_context *gen7_mfd_context)
1784 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1785 VAPictureParameterBufferVC1 *pic_param;
1786 int intensitycomp_single;
1788 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1789 pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
1791 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1792 pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
1793 intensitycomp_single = (pic_param->mv_fields.bits.mv_mode == VAMvModeIntensityCompensation);
1795 BEGIN_BCS_BATCH(batch, 6);
1796 OUT_BCS_BATCH(batch, MFX_VC1_PRED_PIPE_STATE | (6 - 2));
1797 OUT_BCS_BATCH(batch,
1798 0 << 14 | /* FIXME: double ??? */
1800 intensitycomp_single << 10 |
1801 intensitycomp_single << 8 |
1802 0 << 4 | /* FIXME: interlace mode */
1804 OUT_BCS_BATCH(batch,
1805 pic_param->luma_shift << 16 |
1806 pic_param->luma_scale << 0); /* FIXME: Luma Scaling */
1807 OUT_BCS_BATCH(batch, 0);
1808 OUT_BCS_BATCH(batch, 0);
1809 OUT_BCS_BATCH(batch, 0);
1810 ADVANCE_BCS_BATCH(batch);
1815 gen7_mfd_vc1_directmode_state(VADriverContextP ctx,
1816 struct decode_state *decode_state,
1817 struct gen7_mfd_context *gen7_mfd_context)
1819 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1820 VAPictureParameterBufferVC1 *pic_param;
1821 struct i965_driver_data *i965 = i965_driver_data(ctx);
1822 struct object_surface *obj_surface;
1823 dri_bo *dmv_read_buffer = NULL, *dmv_write_buffer = NULL;
1825 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1826 pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
1828 obj_surface = SURFACE(decode_state->current_render_target);
1830 if (obj_surface && obj_surface->private_data) {
1831 dmv_write_buffer = ((struct gen7_vc1_surface *)(obj_surface->private_data))->dmv;
1834 obj_surface = SURFACE(pic_param->backward_reference_picture);
1836 if (obj_surface && obj_surface->private_data) {
1837 dmv_read_buffer = ((struct gen7_vc1_surface *)(obj_surface->private_data))->dmv;
1840 BEGIN_BCS_BATCH(batch, 3);
1841 OUT_BCS_BATCH(batch, MFX_VC1_DIRECTMODE_STATE | (3 - 2));
1843 if (dmv_write_buffer)
1844 OUT_BCS_RELOC(batch, dmv_write_buffer,
1845 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
1848 OUT_BCS_BATCH(batch, 0);
1850 if (dmv_read_buffer)
1851 OUT_BCS_RELOC(batch, dmv_read_buffer,
1852 I915_GEM_DOMAIN_INSTRUCTION, 0,
1855 OUT_BCS_BATCH(batch, 0);
1857 ADVANCE_BCS_BATCH(batch);
1861 gen7_mfd_vc1_get_macroblock_bit_offset(uint8_t *buf, int in_slice_data_bit_offset, int profile)
1863 int out_slice_data_bit_offset;
1864 int slice_header_size = in_slice_data_bit_offset / 8;
1868 out_slice_data_bit_offset = in_slice_data_bit_offset;
1870 for (i = 0, j = 0; i < slice_header_size; i++, j++) {
1871 if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4) {
1876 out_slice_data_bit_offset = 8 * j + in_slice_data_bit_offset % 8;
1879 return out_slice_data_bit_offset;
1883 gen7_mfd_vc1_bsd_object(VADriverContextP ctx,
1884 VAPictureParameterBufferVC1 *pic_param,
1885 VASliceParameterBufferVC1 *slice_param,
1886 VASliceParameterBufferVC1 *next_slice_param,
1887 dri_bo *slice_data_bo,
1888 struct gen7_mfd_context *gen7_mfd_context)
1890 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1891 int next_slice_start_vert_pos;
1892 int macroblock_offset;
1893 uint8_t *slice_data = NULL;
1895 dri_bo_map(slice_data_bo, 0);
1896 slice_data = (uint8_t *)(slice_data_bo->virtual + slice_param->slice_data_offset);
1897 macroblock_offset = gen7_mfd_vc1_get_macroblock_bit_offset(slice_data,
1898 slice_param->macroblock_offset,
1899 pic_param->sequence_fields.bits.profile);
1900 dri_bo_unmap(slice_data_bo);
1902 if (next_slice_param)
1903 next_slice_start_vert_pos = next_slice_param->slice_vertical_position;
1905 next_slice_start_vert_pos = ALIGN(pic_param->coded_height, 16) / 16;
1907 BEGIN_BCS_BATCH(batch, 5);
1908 OUT_BCS_BATCH(batch, MFD_VC1_BSD_OBJECT | (5 - 2));
1909 OUT_BCS_BATCH(batch,
1910 slice_param->slice_data_size - (macroblock_offset >> 3));
1911 OUT_BCS_BATCH(batch,
1912 slice_param->slice_data_offset + (macroblock_offset >> 3));
1913 OUT_BCS_BATCH(batch,
1914 slice_param->slice_vertical_position << 16 |
1915 next_slice_start_vert_pos << 0);
1916 OUT_BCS_BATCH(batch,
1917 (macroblock_offset & 0x7));
1918 ADVANCE_BCS_BATCH(batch);
1922 gen7_mfd_vc1_decode_picture(VADriverContextP ctx,
1923 struct decode_state *decode_state,
1924 struct gen7_mfd_context *gen7_mfd_context)
1926 struct intel_batchbuffer *batch = gen7_mfd_context->base.batch;
1927 VAPictureParameterBufferVC1 *pic_param;
1928 VASliceParameterBufferVC1 *slice_param, *next_slice_param;
1929 dri_bo *slice_data_bo;
1932 assert(decode_state->pic_param && decode_state->pic_param->buffer);
1933 pic_param = (VAPictureParameterBufferVC1 *)decode_state->pic_param->buffer;
1935 gen7_mfd_vc1_decode_init(ctx, decode_state, gen7_mfd_context);
1936 intel_batchbuffer_start_atomic_bcs(batch, 0x1000);
1937 intel_batchbuffer_emit_mi_flush(batch);
1938 gen7_mfd_pipe_mode_select(ctx, decode_state, MFX_FORMAT_VC1, gen7_mfd_context);
1939 gen7_mfd_surface_state(ctx, decode_state, MFX_FORMAT_VC1, gen7_mfd_context);
1940 gen7_mfd_pipe_buf_addr_state(ctx, decode_state, MFX_FORMAT_VC1, gen7_mfd_context);
1941 gen7_mfd_bsp_buf_base_addr_state(ctx, decode_state, MFX_FORMAT_VC1, gen7_mfd_context);
1942 gen7_mfd_vc1_pic_state(ctx, decode_state, gen7_mfd_context);
1943 gen7_mfd_vc1_pred_pipe_state(ctx, decode_state, gen7_mfd_context);
1944 gen7_mfd_vc1_directmode_state(ctx, decode_state, gen7_mfd_context);
1946 assert(decode_state->num_slice_params == 1);
1947 for (j = 0; j < decode_state->num_slice_params; j++) {
1948 assert(decode_state->slice_params && decode_state->slice_params[j]->buffer);
1949 slice_param = (VASliceParameterBufferVC1 *)decode_state->slice_params[j]->buffer;
1950 slice_data_bo = decode_state->slice_datas[j]->bo;
1951 gen7_mfd_ind_obj_base_addr_state(ctx, slice_data_bo, MFX_FORMAT_VC1, gen7_mfd_context);
1953 for (i = 0; i < decode_state->slice_params[j]->num_elements; i++) {
1954 assert(slice_param->slice_data_flag == VA_SLICE_DATA_FLAG_ALL);
1956 if (i < decode_state->slice_params[j]->num_elements - 1)
1957 next_slice_param = slice_param + 1;
1959 next_slice_param = NULL;
1961 gen7_mfd_vc1_bsd_object(ctx, pic_param, slice_param, next_slice_param, slice_data_bo, gen7_mfd_context);
1966 intel_batchbuffer_end_atomic(batch);
1967 intel_batchbuffer_flush(batch);
1971 gen7_mfd_decode_picture(VADriverContextP ctx,
1973 union codec_state *codec_state,
1974 struct hw_context *hw_context)
1977 struct gen7_mfd_context *gen7_mfd_context = (struct gen7_mfd_context *)hw_context;
1978 struct decode_state *decode_state = &codec_state->dec;
1980 assert(gen7_mfd_context);
1983 case VAProfileMPEG2Simple:
1984 case VAProfileMPEG2Main:
1985 gen7_mfd_mpeg2_decode_picture(ctx, decode_state, gen7_mfd_context);
1988 case VAProfileH264Baseline:
1989 case VAProfileH264Main:
1990 case VAProfileH264High:
1991 gen7_mfd_avc_decode_picture(ctx, decode_state, gen7_mfd_context);
1994 case VAProfileVC1Simple:
1995 case VAProfileVC1Main:
1996 case VAProfileVC1Advanced:
1997 gen7_mfd_vc1_decode_picture(ctx, decode_state, gen7_mfd_context);
2007 gen7_mfd_context_destroy(void *hw_context)
2009 struct gen7_mfd_context *gen7_mfd_context = (struct gen7_mfd_context *)hw_context;
2011 dri_bo_unreference(gen7_mfd_context->post_deblocking_output.bo);
2012 gen7_mfd_context->post_deblocking_output.bo = NULL;
2014 dri_bo_unreference(gen7_mfd_context->pre_deblocking_output.bo);
2015 gen7_mfd_context->pre_deblocking_output.bo = NULL;
2017 dri_bo_unreference(gen7_mfd_context->intra_row_store_scratch_buffer.bo);
2018 gen7_mfd_context->intra_row_store_scratch_buffer.bo = NULL;
2020 dri_bo_unreference(gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo);
2021 gen7_mfd_context->deblocking_filter_row_store_scratch_buffer.bo = NULL;
2023 dri_bo_unreference(gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo);
2024 gen7_mfd_context->bsd_mpc_row_store_scratch_buffer.bo = NULL;
2026 dri_bo_unreference(gen7_mfd_context->mpr_row_store_scratch_buffer.bo);
2027 gen7_mfd_context->mpr_row_store_scratch_buffer.bo = NULL;
2029 dri_bo_unreference(gen7_mfd_context->bitplane_read_buffer.bo);
2030 gen7_mfd_context->bitplane_read_buffer.bo = NULL;
2032 intel_batchbuffer_free(gen7_mfd_context->base.batch);
2033 free(gen7_mfd_context);
2037 gen7_dec_hw_context_init(VADriverContextP ctx, VAProfile profile)
2039 struct intel_driver_data *intel = intel_driver_data(ctx);
2040 struct gen7_mfd_context *gen7_mfd_context = calloc(1, sizeof(struct gen7_mfd_context));
2043 gen7_mfd_context->base.destroy = gen7_mfd_context_destroy;
2044 gen7_mfd_context->base.run = gen7_mfd_decode_picture;
2045 gen7_mfd_context->base.batch = intel_batchbuffer_new(intel, I915_EXEC_RENDER);
2047 for (i = 0; i < ARRAY_ELEMS(gen7_mfd_context->reference_surface); i++) {
2048 gen7_mfd_context->reference_surface[i].surface_id = VA_INVALID_ID;
2049 gen7_mfd_context->reference_surface[i].frame_store_id = -1;
2052 return (struct hw_context *)gen7_mfd_context;