2 * Copyright © 2010-2012 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 * Zhao Yakui <yakui.zhao@intel.com>
26 * Xiang Haihao <haihao.xiang@intel.com>
36 #include "intel_batchbuffer.h"
37 #include "i965_defines.h"
38 #include "i965_structs.h"
39 #include "i965_drv_video.h"
40 #include "i965_encoder.h"
41 #include "i965_encoder_utils.h"
44 #include "intel_media.h"
46 #define AVC_INTRA_RDO_OFFSET 4
47 #define AVC_INTER_RDO_OFFSET 10
48 #define AVC_INTER_MSG_OFFSET 8
49 #define AVC_INTER_MV_OFFSET 48
50 #define AVC_RDO_MASK 0xFFFF
52 #define SURFACE_STATE_PADDED_SIZE MAX(SURFACE_STATE_PADDED_SIZE_GEN6, SURFACE_STATE_PADDED_SIZE_GEN7)
53 #define SURFACE_STATE_OFFSET(index) (SURFACE_STATE_PADDED_SIZE * index)
54 #define BINDING_TABLE_OFFSET(index) (SURFACE_STATE_OFFSET(MAX_MEDIA_SURFACES_GEN6) + sizeof(unsigned int) * index)
57 #define IS_STEPPING_BPLUS(i965) ((i965->intel.revision) >= B0_STEP_REV)
59 static const uint32_t gen75_mfc_batchbuffer_avc[][4] = {
60 #include "shaders/utils/mfc_batchbuffer_hsw.g75b"
63 static struct i965_kernel gen75_mfc_kernels[] = {
65 "MFC AVC INTRA BATCHBUFFER ",
66 MFC_BATCHBUFFER_AVC_INTRA,
67 gen75_mfc_batchbuffer_avc,
68 sizeof(gen75_mfc_batchbuffer_avc),
73 #define INTER_MODE_MASK 0x03
74 #define INTER_8X8 0x03
75 #define INTER_16X8 0x01
76 #define INTER_8X16 0x02
77 #define SUBMB_SHAPE_MASK 0x00FF00
79 #define INTER_MV8 (4 << 20)
80 #define INTER_MV32 (6 << 20)
84 gen75_mfc_pipe_mode_select(VADriverContextP ctx,
86 struct intel_encoder_context *encoder_context)
88 struct intel_batchbuffer *batch = encoder_context->base.batch;
89 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
90 assert(standard_select == MFX_FORMAT_MPEG2 ||
91 standard_select == MFX_FORMAT_AVC);
93 BEGIN_BCS_BATCH(batch, 5);
95 OUT_BCS_BATCH(batch, MFX_PIPE_MODE_SELECT | (5 - 2));
97 (MFX_LONG_MODE << 17) | /* Must be long format for encoder */
98 (MFD_MODE_VLD << 15) | /* VLD mode */
99 (0 << 10) | /* Stream-Out Enable */
100 ((!!mfc_context->post_deblocking_output.bo) << 9) | /* Post Deblocking Output */
101 ((!!mfc_context->pre_deblocking_output.bo) << 8) | /* Pre Deblocking Output */
102 (0 << 5) | /* not in stitch mode */
103 (1 << 4) | /* encoding mode */
104 (standard_select << 0)); /* standard select: avc or mpeg2 */
106 (0 << 7) | /* expand NOA bus flag */
107 (0 << 6) | /* disable slice-level clock gating */
108 (0 << 5) | /* disable clock gating for NOA */
109 (0 << 4) | /* terminate if AVC motion and POC table error occurs */
110 (0 << 3) | /* terminate if AVC mbdata error occurs */
111 (0 << 2) | /* terminate if AVC CABAC/CAVLC decode error occurs */
114 OUT_BCS_BATCH(batch, 0);
115 OUT_BCS_BATCH(batch, 0);
117 ADVANCE_BCS_BATCH(batch);
121 gen75_mfc_surface_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
123 struct intel_batchbuffer *batch = encoder_context->base.batch;
124 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
126 BEGIN_BCS_BATCH(batch, 6);
128 OUT_BCS_BATCH(batch, MFX_SURFACE_STATE | (6 - 2));
129 OUT_BCS_BATCH(batch, 0);
131 ((mfc_context->surface_state.height - 1) << 18) |
132 ((mfc_context->surface_state.width - 1) << 4));
134 (MFX_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface */
135 (1 << 27) | /* must be 1 for interleave U/V, hardware requirement */
136 (0 << 22) | /* surface object control state, FIXME??? */
137 ((mfc_context->surface_state.w_pitch - 1) << 3) | /* pitch */
138 (0 << 2) | /* must be 0 for interleave U/V */
139 (1 << 1) | /* must be tiled */
140 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, TILEWALK_YMAJOR */
142 (0 << 16) | /* must be 0 for interleave U/V */
143 (mfc_context->surface_state.h_pitch)); /* y offset for U(cb) */
144 OUT_BCS_BATCH(batch, 0);
146 ADVANCE_BCS_BATCH(batch);
150 gen75_mfc_ind_obj_base_addr_state_bplus(VADriverContextP ctx,
151 struct intel_encoder_context *encoder_context)
153 struct intel_batchbuffer *batch = encoder_context->base.batch;
154 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
155 struct gen6_vme_context *vme_context = encoder_context->vme_context;
157 BEGIN_BCS_BATCH(batch, 26);
159 OUT_BCS_BATCH(batch, MFX_IND_OBJ_BASE_ADDR_STATE | (26 - 2));
160 /* the DW1-3 is for the MFX indirect bistream offset */
161 OUT_BCS_BATCH(batch, 0);
162 OUT_BCS_BATCH(batch, 0);
163 OUT_BCS_BATCH(batch, 0);
164 /* the DW4-5 is the MFX upper bound */
165 OUT_BCS_BATCH(batch, 0);
166 OUT_BCS_BATCH(batch, 0);
168 /* the DW6-10 is for MFX Indirect MV Object Base Address */
169 OUT_BCS_RELOC(batch, vme_context->vme_output.bo, I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
170 OUT_BCS_BATCH(batch, 0);
171 OUT_BCS_BATCH(batch, 0);
172 OUT_BCS_BATCH(batch, 0x80000000); /* must set, up to 2G */
173 OUT_BCS_BATCH(batch, 0);
175 /* the DW11-15 is for MFX IT-COFF. Not used on encoder */
176 OUT_BCS_BATCH(batch, 0);
177 OUT_BCS_BATCH(batch, 0);
178 OUT_BCS_BATCH(batch, 0);
179 OUT_BCS_BATCH(batch, 0);
180 OUT_BCS_BATCH(batch, 0);
182 /* the DW16-20 is for MFX indirect DBLK. Not used on encoder */
183 OUT_BCS_BATCH(batch, 0);
184 OUT_BCS_BATCH(batch, 0);
185 OUT_BCS_BATCH(batch, 0);
186 OUT_BCS_BATCH(batch, 0);
187 OUT_BCS_BATCH(batch, 0);
189 /* the DW21-25 is for MFC Indirect PAK-BSE Object Base Address for Encoder*/
191 mfc_context->mfc_indirect_pak_bse_object.bo,
192 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
194 OUT_BCS_BATCH(batch, 0);
195 OUT_BCS_BATCH(batch, 0);
198 mfc_context->mfc_indirect_pak_bse_object.bo,
199 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
200 mfc_context->mfc_indirect_pak_bse_object.end_offset);
201 OUT_BCS_BATCH(batch, 0);
203 ADVANCE_BCS_BATCH(batch);
207 gen75_mfc_ind_obj_base_addr_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
209 struct intel_batchbuffer *batch = encoder_context->base.batch;
210 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
211 struct gen6_vme_context *vme_context = encoder_context->vme_context;
212 struct i965_driver_data *i965 = i965_driver_data(ctx);
214 if (IS_STEPPING_BPLUS(i965)) {
215 gen75_mfc_ind_obj_base_addr_state_bplus(ctx, encoder_context);
219 BEGIN_BCS_BATCH(batch, 11);
221 OUT_BCS_BATCH(batch, MFX_IND_OBJ_BASE_ADDR_STATE | (11 - 2));
222 OUT_BCS_BATCH(batch, 0);
223 OUT_BCS_BATCH(batch, 0);
224 /* MFX Indirect MV Object Base Address */
225 OUT_BCS_RELOC(batch, vme_context->vme_output.bo, I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
226 OUT_BCS_BATCH(batch, 0x80000000); /* must set, up to 2G */
227 OUT_BCS_BATCH(batch, 0);
228 OUT_BCS_BATCH(batch, 0);
229 OUT_BCS_BATCH(batch, 0);
230 OUT_BCS_BATCH(batch, 0);
231 /*MFC Indirect PAK-BSE Object Base Address for Encoder*/
233 mfc_context->mfc_indirect_pak_bse_object.bo,
234 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
237 mfc_context->mfc_indirect_pak_bse_object.bo,
238 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
239 mfc_context->mfc_indirect_pak_bse_object.end_offset);
241 ADVANCE_BCS_BATCH(batch);
245 gen75_mfc_avc_img_state(VADriverContextP ctx, struct encode_state *encode_state,
246 struct intel_encoder_context *encoder_context)
248 struct intel_batchbuffer *batch = encoder_context->base.batch;
249 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
250 VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
252 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
253 int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
255 BEGIN_BCS_BATCH(batch, 16);
257 OUT_BCS_BATCH(batch, MFX_AVC_IMG_STATE | (16 - 2));
258 /*DW1. MB setting of frame */
260 ((width_in_mbs * height_in_mbs - 1) & 0xFFFF));
262 ((height_in_mbs - 1) << 16) |
263 ((width_in_mbs - 1) << 0));
266 (0 << 24) | /* Second Chroma QP Offset */
267 (0 << 16) | /* Chroma QP Offset */
268 (0 << 14) | /* Max-bit conformance Intra flag */
269 (0 << 13) | /* Max Macroblock size conformance Inter flag */
270 (pPicParameter->pic_fields.bits.weighted_pred_flag << 12) | /*Weighted_Pred_Flag */
271 (pPicParameter->pic_fields.bits.weighted_bipred_idc << 10) | /* Weighted_BiPred_Idc */
272 (0 << 8) | /* FIXME: Image Structure */
273 (0 << 0) ); /* Current Decoed Image Frame Store ID, reserved in Encode mode */
275 (0 << 16) | /* Mininum Frame size */
276 (0 << 15) | /* Disable reading of Macroblock Status Buffer */
277 (0 << 14) | /* Load BitStream Pointer only once, 1 slic 1 frame */
278 (0 << 13) | /* CABAC 0 word insertion test enable */
279 (1 << 12) | /* MVUnpackedEnable,compliant to DXVA */
280 (1 << 10) | /* Chroma Format IDC, 4:2:0 */
281 (0 << 8) | /* FIXME: MbMvFormatFlag */
282 (pPicParameter->pic_fields.bits.entropy_coding_mode_flag << 7) | /*0:CAVLC encoding mode,1:CABAC*/
283 (0 << 6) | /* Only valid for VLD decoding mode */
284 (0 << 5) | /* Constrained Intra Predition Flag, from PPS */
285 (0 << 4) | /* Direct 8x8 inference flag */
286 (pPicParameter->pic_fields.bits.transform_8x8_mode_flag << 3) | /*8x8 or 4x4 IDCT Transform Mode Flag*/
287 (1 << 2) | /* Frame MB only flag */
288 (0 << 1) | /* MBAFF mode is in active */
289 (0 << 0)); /* Field picture flag */
290 /* DW5 Trellis quantization */
291 OUT_BCS_BATCH(batch, 0); /* Mainly about MB rate control and debug, just ignoring */
292 OUT_BCS_BATCH(batch, /* Inter and Intra Conformance Max size limit */
293 (0xBB8 << 16) | /* InterMbMaxSz */
294 (0xEE8) ); /* IntraMbMaxSz */
295 OUT_BCS_BATCH(batch, 0); /* Reserved */
297 OUT_BCS_BATCH(batch, 0); /* Slice QP Delta for bitrate control */
298 OUT_BCS_BATCH(batch, 0); /* Slice QP Delta for bitrate control */
299 /* DW10. Bit setting for MB */
300 OUT_BCS_BATCH(batch, 0x8C000000);
301 OUT_BCS_BATCH(batch, 0x00010000);
303 OUT_BCS_BATCH(batch, 0);
304 OUT_BCS_BATCH(batch, 0x02010100);
305 /* DW14. For short format */
306 OUT_BCS_BATCH(batch, 0);
307 OUT_BCS_BATCH(batch, 0);
309 ADVANCE_BCS_BATCH(batch);
313 gen75_mfc_qm_state(VADriverContextP ctx,
317 struct intel_encoder_context *encoder_context)
319 struct intel_batchbuffer *batch = encoder_context->base.batch;
320 unsigned int qm_buffer[16];
322 assert(qm_length <= 16);
323 assert(sizeof(*qm) == 4);
324 memcpy(qm_buffer, qm, qm_length * 4);
326 BEGIN_BCS_BATCH(batch, 18);
327 OUT_BCS_BATCH(batch, MFX_QM_STATE | (18 - 2));
328 OUT_BCS_BATCH(batch, qm_type << 0);
329 intel_batchbuffer_data(batch, qm_buffer, 16 * 4);
330 ADVANCE_BCS_BATCH(batch);
334 gen75_mfc_avc_qm_state(VADriverContextP ctx,
335 struct encode_state *encode_state,
336 struct intel_encoder_context *encoder_context)
338 unsigned int qm[16] = {
339 0x10101010, 0x10101010, 0x10101010, 0x10101010,
340 0x10101010, 0x10101010, 0x10101010, 0x10101010,
341 0x10101010, 0x10101010, 0x10101010, 0x10101010,
342 0x10101010, 0x10101010, 0x10101010, 0x10101010
345 gen75_mfc_qm_state(ctx, MFX_QM_AVC_4X4_INTRA_MATRIX, qm, 12, encoder_context);
346 gen75_mfc_qm_state(ctx, MFX_QM_AVC_4X4_INTER_MATRIX, qm, 12, encoder_context);
347 gen75_mfc_qm_state(ctx, MFX_QM_AVC_8x8_INTRA_MATRIX, qm, 16, encoder_context);
348 gen75_mfc_qm_state(ctx, MFX_QM_AVC_8x8_INTER_MATRIX, qm, 16, encoder_context);
352 gen75_mfc_fqm_state(VADriverContextP ctx,
356 struct intel_encoder_context *encoder_context)
358 struct intel_batchbuffer *batch = encoder_context->base.batch;
359 unsigned int fqm_buffer[32];
361 assert(fqm_length <= 32);
362 assert(sizeof(*fqm) == 4);
363 memcpy(fqm_buffer, fqm, fqm_length * 4);
365 BEGIN_BCS_BATCH(batch, 34);
366 OUT_BCS_BATCH(batch, MFX_FQM_STATE | (34 - 2));
367 OUT_BCS_BATCH(batch, fqm_type << 0);
368 intel_batchbuffer_data(batch, fqm_buffer, 32 * 4);
369 ADVANCE_BCS_BATCH(batch);
373 gen75_mfc_avc_fqm_state(VADriverContextP ctx,
374 struct encode_state *encode_state,
375 struct intel_encoder_context *encoder_context)
377 unsigned int qm[32] = {
378 0x10001000, 0x10001000, 0x10001000, 0x10001000,
379 0x10001000, 0x10001000, 0x10001000, 0x10001000,
380 0x10001000, 0x10001000, 0x10001000, 0x10001000,
381 0x10001000, 0x10001000, 0x10001000, 0x10001000,
382 0x10001000, 0x10001000, 0x10001000, 0x10001000,
383 0x10001000, 0x10001000, 0x10001000, 0x10001000,
384 0x10001000, 0x10001000, 0x10001000, 0x10001000,
385 0x10001000, 0x10001000, 0x10001000, 0x10001000
388 gen75_mfc_fqm_state(ctx, MFX_QM_AVC_4X4_INTRA_MATRIX, qm, 24, encoder_context);
389 gen75_mfc_fqm_state(ctx, MFX_QM_AVC_4X4_INTER_MATRIX, qm, 24, encoder_context);
390 gen75_mfc_fqm_state(ctx, MFX_QM_AVC_8x8_INTRA_MATRIX, qm, 32, encoder_context);
391 gen75_mfc_fqm_state(ctx, MFX_QM_AVC_8x8_INTER_MATRIX, qm, 32, encoder_context);
395 gen75_mfc_avc_insert_object(VADriverContextP ctx, struct intel_encoder_context *encoder_context,
396 unsigned int *insert_data, int lenght_in_dws, int data_bits_in_last_dw,
397 int skip_emul_byte_count, int is_last_header, int is_end_of_slice, int emulation_flag,
398 struct intel_batchbuffer *batch)
401 batch = encoder_context->base.batch;
403 BEGIN_BCS_BATCH(batch, lenght_in_dws + 2);
405 OUT_BCS_BATCH(batch, MFX_INSERT_OBJECT | (lenght_in_dws + 2 - 2));
407 (0 << 16) | /* always start at offset 0 */
408 (data_bits_in_last_dw << 8) |
409 (skip_emul_byte_count << 4) |
410 (!!emulation_flag << 3) |
411 ((!!is_last_header) << 2) |
412 ((!!is_end_of_slice) << 1) |
413 (0 << 0)); /* FIXME: ??? */
414 intel_batchbuffer_data(batch, insert_data, lenght_in_dws * 4);
416 ADVANCE_BCS_BATCH(batch);
420 static void gen75_mfc_init(VADriverContextP ctx,
421 struct encode_state *encode_state,
422 struct intel_encoder_context *encoder_context)
424 struct i965_driver_data *i965 = i965_driver_data(ctx);
425 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
428 int width_in_mbs = 0;
429 int height_in_mbs = 0;
430 int slice_batchbuffer_size;
432 if (encoder_context->codec == CODEC_H264 ||
433 encoder_context->codec == CODEC_H264_MVC) {
434 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
435 width_in_mbs = pSequenceParameter->picture_width_in_mbs;
436 height_in_mbs = pSequenceParameter->picture_height_in_mbs;
438 VAEncSequenceParameterBufferMPEG2 *pSequenceParameter = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
440 assert(encoder_context->codec == CODEC_MPEG2);
442 width_in_mbs = ALIGN(pSequenceParameter->picture_width, 16) / 16;
443 height_in_mbs = ALIGN(pSequenceParameter->picture_height, 16) / 16;
446 slice_batchbuffer_size = 64 * width_in_mbs * height_in_mbs + 4096 +
447 (SLICE_HEADER + SLICE_TAIL) * encode_state->num_slice_params_ext;
449 /*Encode common setup for MFC*/
450 dri_bo_unreference(mfc_context->post_deblocking_output.bo);
451 mfc_context->post_deblocking_output.bo = NULL;
453 dri_bo_unreference(mfc_context->pre_deblocking_output.bo);
454 mfc_context->pre_deblocking_output.bo = NULL;
456 dri_bo_unreference(mfc_context->uncompressed_picture_source.bo);
457 mfc_context->uncompressed_picture_source.bo = NULL;
459 dri_bo_unreference(mfc_context->mfc_indirect_pak_bse_object.bo);
460 mfc_context->mfc_indirect_pak_bse_object.bo = NULL;
462 for (i = 0; i < NUM_MFC_DMV_BUFFERS; i++){
463 if (mfc_context->direct_mv_buffers[i].bo != NULL)
464 dri_bo_unreference(mfc_context->direct_mv_buffers[i].bo);
465 mfc_context->direct_mv_buffers[i].bo = NULL;
468 for (i = 0; i < MAX_MFC_REFERENCE_SURFACES; i++){
469 if (mfc_context->reference_surfaces[i].bo != NULL)
470 dri_bo_unreference(mfc_context->reference_surfaces[i].bo);
471 mfc_context->reference_surfaces[i].bo = NULL;
474 dri_bo_unreference(mfc_context->intra_row_store_scratch_buffer.bo);
475 bo = dri_bo_alloc(i965->intel.bufmgr,
480 mfc_context->intra_row_store_scratch_buffer.bo = bo;
482 dri_bo_unreference(mfc_context->macroblock_status_buffer.bo);
483 bo = dri_bo_alloc(i965->intel.bufmgr,
485 width_in_mbs * height_in_mbs * 16,
488 mfc_context->macroblock_status_buffer.bo = bo;
490 dri_bo_unreference(mfc_context->deblocking_filter_row_store_scratch_buffer.bo);
491 bo = dri_bo_alloc(i965->intel.bufmgr,
493 4 * width_in_mbs * 64, /* 4 * width_in_mbs * 64 */
496 mfc_context->deblocking_filter_row_store_scratch_buffer.bo = bo;
498 dri_bo_unreference(mfc_context->bsd_mpc_row_store_scratch_buffer.bo);
499 bo = dri_bo_alloc(i965->intel.bufmgr,
501 2 * width_in_mbs * 64, /* 2 * width_in_mbs * 64 */
504 mfc_context->bsd_mpc_row_store_scratch_buffer.bo = bo;
506 dri_bo_unreference(mfc_context->mfc_batchbuffer_surface.bo);
507 mfc_context->mfc_batchbuffer_surface.bo = NULL;
509 dri_bo_unreference(mfc_context->aux_batchbuffer_surface.bo);
510 mfc_context->aux_batchbuffer_surface.bo = NULL;
512 if (mfc_context->aux_batchbuffer)
513 intel_batchbuffer_free(mfc_context->aux_batchbuffer);
515 mfc_context->aux_batchbuffer = intel_batchbuffer_new(&i965->intel, I915_EXEC_BSD,
516 slice_batchbuffer_size);
517 mfc_context->aux_batchbuffer_surface.bo = mfc_context->aux_batchbuffer->buffer;
518 dri_bo_reference(mfc_context->aux_batchbuffer_surface.bo);
519 mfc_context->aux_batchbuffer_surface.pitch = 16;
520 mfc_context->aux_batchbuffer_surface.num_blocks = mfc_context->aux_batchbuffer->size / 16;
521 mfc_context->aux_batchbuffer_surface.size_block = 16;
523 i965_gpe_context_init(ctx, &mfc_context->gpe_context);
527 gen75_mfc_pipe_buf_addr_state_bplus(VADriverContextP ctx,
528 struct intel_encoder_context *encoder_context)
530 struct intel_batchbuffer *batch = encoder_context->base.batch;
531 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
534 BEGIN_BCS_BATCH(batch, 61);
536 OUT_BCS_BATCH(batch, MFX_PIPE_BUF_ADDR_STATE | (61 - 2));
538 /* the DW1-3 is for pre_deblocking */
539 if (mfc_context->pre_deblocking_output.bo)
540 OUT_BCS_RELOC(batch, mfc_context->pre_deblocking_output.bo,
541 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
544 OUT_BCS_BATCH(batch, 0); /* pre output addr */
546 OUT_BCS_BATCH(batch, 0);
547 OUT_BCS_BATCH(batch, 0);
548 /* the DW4-6 is for the post_deblocking */
550 if (mfc_context->post_deblocking_output.bo)
551 OUT_BCS_RELOC(batch, mfc_context->post_deblocking_output.bo,
552 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
553 0); /* post output addr */
555 OUT_BCS_BATCH(batch, 0);
556 OUT_BCS_BATCH(batch, 0);
557 OUT_BCS_BATCH(batch, 0);
559 /* the DW7-9 is for the uncompressed_picture */
560 OUT_BCS_RELOC(batch, mfc_context->uncompressed_picture_source.bo,
561 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
562 0); /* uncompressed data */
564 OUT_BCS_BATCH(batch, 0);
565 OUT_BCS_BATCH(batch, 0);
567 /* the DW10-12 is for the mb status */
568 OUT_BCS_RELOC(batch, mfc_context->macroblock_status_buffer.bo,
569 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
570 0); /* StreamOut data*/
571 OUT_BCS_BATCH(batch, 0);
572 OUT_BCS_BATCH(batch, 0);
574 /* the DW13-15 is for the intra_row_store_scratch */
575 OUT_BCS_RELOC(batch, mfc_context->intra_row_store_scratch_buffer.bo,
576 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
578 OUT_BCS_BATCH(batch, 0);
579 OUT_BCS_BATCH(batch, 0);
581 /* the DW16-18 is for the deblocking filter */
582 OUT_BCS_RELOC(batch, mfc_context->deblocking_filter_row_store_scratch_buffer.bo,
583 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
585 OUT_BCS_BATCH(batch, 0);
586 OUT_BCS_BATCH(batch, 0);
588 /* the DW 19-50 is for Reference pictures*/
589 for (i = 0; i < ARRAY_ELEMS(mfc_context->reference_surfaces); i++) {
590 if ( mfc_context->reference_surfaces[i].bo != NULL) {
591 OUT_BCS_RELOC(batch, mfc_context->reference_surfaces[i].bo,
592 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
595 OUT_BCS_BATCH(batch, 0);
597 OUT_BCS_BATCH(batch, 0);
599 OUT_BCS_BATCH(batch, 0);
601 /* The DW 52-54 is for the MB status buffer */
602 OUT_BCS_RELOC(batch, mfc_context->macroblock_status_buffer.bo,
603 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
604 0); /* Macroblock status buffer*/
606 OUT_BCS_BATCH(batch, 0);
607 OUT_BCS_BATCH(batch, 0);
609 /* the DW 55-57 is the ILDB buffer */
610 OUT_BCS_BATCH(batch, 0);
611 OUT_BCS_BATCH(batch, 0);
612 OUT_BCS_BATCH(batch, 0);
614 /* the DW 58-60 is the second ILDB buffer */
615 OUT_BCS_BATCH(batch, 0);
616 OUT_BCS_BATCH(batch, 0);
617 OUT_BCS_BATCH(batch, 0);
618 ADVANCE_BCS_BATCH(batch);
622 gen75_mfc_pipe_buf_addr_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
624 struct intel_batchbuffer *batch = encoder_context->base.batch;
625 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
626 struct i965_driver_data *i965 = i965_driver_data(ctx);
629 if (IS_STEPPING_BPLUS(i965)) {
630 gen75_mfc_pipe_buf_addr_state_bplus(ctx, encoder_context);
634 BEGIN_BCS_BATCH(batch, 25);
636 OUT_BCS_BATCH(batch, MFX_PIPE_BUF_ADDR_STATE | (25 - 2));
638 if (mfc_context->pre_deblocking_output.bo)
639 OUT_BCS_RELOC(batch, mfc_context->pre_deblocking_output.bo,
640 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
643 OUT_BCS_BATCH(batch, 0); /* pre output addr */
645 if (mfc_context->post_deblocking_output.bo)
646 OUT_BCS_RELOC(batch, mfc_context->post_deblocking_output.bo,
647 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
648 0); /* post output addr */
650 OUT_BCS_BATCH(batch, 0);
652 OUT_BCS_RELOC(batch, mfc_context->uncompressed_picture_source.bo,
653 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
654 0); /* uncompressed data */
655 OUT_BCS_RELOC(batch, mfc_context->macroblock_status_buffer.bo,
656 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
657 0); /* StreamOut data*/
658 OUT_BCS_RELOC(batch, mfc_context->intra_row_store_scratch_buffer.bo,
659 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
661 OUT_BCS_RELOC(batch, mfc_context->deblocking_filter_row_store_scratch_buffer.bo,
662 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
664 /* 7..22 Reference pictures*/
665 for (i = 0; i < ARRAY_ELEMS(mfc_context->reference_surfaces); i++) {
666 if ( mfc_context->reference_surfaces[i].bo != NULL) {
667 OUT_BCS_RELOC(batch, mfc_context->reference_surfaces[i].bo,
668 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
671 OUT_BCS_BATCH(batch, 0);
674 OUT_BCS_RELOC(batch, mfc_context->macroblock_status_buffer.bo,
675 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
676 0); /* Macroblock status buffer*/
678 OUT_BCS_BATCH(batch, 0);
680 ADVANCE_BCS_BATCH(batch);
684 gen75_mfc_avc_directmode_state_bplus(VADriverContextP ctx,
685 struct intel_encoder_context *encoder_context)
687 struct intel_batchbuffer *batch = encoder_context->base.batch;
688 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
692 BEGIN_BCS_BATCH(batch, 71);
694 OUT_BCS_BATCH(batch, MFX_AVC_DIRECTMODE_STATE | (71 - 2));
696 /* Reference frames and Current frames */
697 /* the DW1-32 is for the direct MV for reference */
698 for(i = 0; i < NUM_MFC_DMV_BUFFERS - 2; i += 2) {
699 if ( mfc_context->direct_mv_buffers[i].bo != NULL) {
700 OUT_BCS_RELOC(batch, mfc_context->direct_mv_buffers[i].bo,
701 I915_GEM_DOMAIN_INSTRUCTION, 0,
703 OUT_BCS_BATCH(batch, 0);
705 OUT_BCS_BATCH(batch, 0);
706 OUT_BCS_BATCH(batch, 0);
709 OUT_BCS_BATCH(batch, 0);
711 /* the DW34-36 is the MV for the current reference */
712 OUT_BCS_RELOC(batch, mfc_context->direct_mv_buffers[NUM_MFC_DMV_BUFFERS - 2].bo,
713 I915_GEM_DOMAIN_INSTRUCTION, 0,
716 OUT_BCS_BATCH(batch, 0);
717 OUT_BCS_BATCH(batch, 0);
720 for(i = 0; i < 32; i++) {
721 OUT_BCS_BATCH(batch, i/2);
723 OUT_BCS_BATCH(batch, 0);
724 OUT_BCS_BATCH(batch, 0);
726 ADVANCE_BCS_BATCH(batch);
730 gen75_mfc_avc_directmode_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
732 struct intel_batchbuffer *batch = encoder_context->base.batch;
733 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
734 struct i965_driver_data *i965 = i965_driver_data(ctx);
737 if (IS_STEPPING_BPLUS(i965)) {
738 gen75_mfc_avc_directmode_state_bplus(ctx, encoder_context);
742 BEGIN_BCS_BATCH(batch, 69);
744 OUT_BCS_BATCH(batch, MFX_AVC_DIRECTMODE_STATE | (69 - 2));
746 /* Reference frames and Current frames */
747 for(i = 0; i < NUM_MFC_DMV_BUFFERS; i++) {
748 if ( mfc_context->direct_mv_buffers[i].bo != NULL) {
749 OUT_BCS_RELOC(batch, mfc_context->direct_mv_buffers[i].bo,
750 I915_GEM_DOMAIN_INSTRUCTION, 0,
753 OUT_BCS_BATCH(batch, 0);
758 for(i = 0; i < 32; i++) {
759 OUT_BCS_BATCH(batch, i/2);
761 OUT_BCS_BATCH(batch, 0);
762 OUT_BCS_BATCH(batch, 0);
764 ADVANCE_BCS_BATCH(batch);
769 gen75_mfc_bsp_buf_base_addr_state_bplus(VADriverContextP ctx,
770 struct intel_encoder_context *encoder_context)
772 struct intel_batchbuffer *batch = encoder_context->base.batch;
773 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
775 BEGIN_BCS_BATCH(batch, 10);
777 OUT_BCS_BATCH(batch, MFX_BSP_BUF_BASE_ADDR_STATE | (10 - 2));
778 OUT_BCS_RELOC(batch, mfc_context->bsd_mpc_row_store_scratch_buffer.bo,
779 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
781 OUT_BCS_BATCH(batch, 0);
782 OUT_BCS_BATCH(batch, 0);
784 /* the DW4-6 is for MPR Row Store Scratch Buffer Base Address */
785 OUT_BCS_BATCH(batch, 0);
786 OUT_BCS_BATCH(batch, 0);
787 OUT_BCS_BATCH(batch, 0);
789 /* the DW7-9 is for Bitplane Read Buffer Base Address */
790 OUT_BCS_BATCH(batch, 0);
791 OUT_BCS_BATCH(batch, 0);
792 OUT_BCS_BATCH(batch, 0);
794 ADVANCE_BCS_BATCH(batch);
798 gen75_mfc_bsp_buf_base_addr_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
800 struct intel_batchbuffer *batch = encoder_context->base.batch;
801 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
802 struct i965_driver_data *i965 = i965_driver_data(ctx);
804 if (IS_STEPPING_BPLUS(i965)) {
805 gen75_mfc_bsp_buf_base_addr_state_bplus(ctx, encoder_context);
809 BEGIN_BCS_BATCH(batch, 4);
811 OUT_BCS_BATCH(batch, MFX_BSP_BUF_BASE_ADDR_STATE | (4 - 2));
812 OUT_BCS_RELOC(batch, mfc_context->bsd_mpc_row_store_scratch_buffer.bo,
813 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
815 OUT_BCS_BATCH(batch, 0);
816 OUT_BCS_BATCH(batch, 0);
818 ADVANCE_BCS_BATCH(batch);
822 static void gen75_mfc_avc_pipeline_picture_programing( VADriverContextP ctx,
823 struct encode_state *encode_state,
824 struct intel_encoder_context *encoder_context)
826 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
828 mfc_context->pipe_mode_select(ctx, MFX_FORMAT_AVC, encoder_context);
829 mfc_context->set_surface_state(ctx, encoder_context);
830 mfc_context->ind_obj_base_addr_state(ctx, encoder_context);
831 gen75_mfc_pipe_buf_addr_state(ctx, encoder_context);
832 gen75_mfc_bsp_buf_base_addr_state(ctx, encoder_context);
833 mfc_context->avc_img_state(ctx, encode_state, encoder_context);
834 mfc_context->avc_qm_state(ctx, encode_state, encoder_context);
835 mfc_context->avc_fqm_state(ctx, encode_state, encoder_context);
836 gen75_mfc_avc_directmode_state(ctx, encoder_context);
837 intel_mfc_avc_ref_idx_state(ctx, encode_state, encoder_context);
841 static VAStatus gen75_mfc_run(VADriverContextP ctx,
842 struct encode_state *encode_state,
843 struct intel_encoder_context *encoder_context)
845 struct intel_batchbuffer *batch = encoder_context->base.batch;
847 intel_batchbuffer_flush(batch); //run the pipeline
849 return VA_STATUS_SUCCESS;
854 gen75_mfc_stop(VADriverContextP ctx,
855 struct encode_state *encode_state,
856 struct intel_encoder_context *encoder_context,
857 int *encoded_bits_size)
859 VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
860 VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
861 VACodedBufferSegment *coded_buffer_segment;
863 vaStatus = i965_MapBuffer(ctx, pPicParameter->coded_buf, (void **)&coded_buffer_segment);
864 assert(vaStatus == VA_STATUS_SUCCESS);
865 *encoded_bits_size = coded_buffer_segment->size * 8;
866 i965_UnmapBuffer(ctx, pPicParameter->coded_buf);
868 return VA_STATUS_SUCCESS;
873 gen75_mfc_avc_slice_state(VADriverContextP ctx,
874 VAEncPictureParameterBufferH264 *pic_param,
875 VAEncSliceParameterBufferH264 *slice_param,
876 struct encode_state *encode_state,
877 struct intel_encoder_context *encoder_context,
878 int rate_control_enable,
880 struct intel_batchbuffer *batch)
882 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
883 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
884 int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
885 int beginmb = slice_param->macroblock_address;
886 int endmb = beginmb + slice_param->num_macroblocks;
887 int beginx = beginmb % width_in_mbs;
888 int beginy = beginmb / width_in_mbs;
889 int nextx = endmb % width_in_mbs;
890 int nexty = endmb / width_in_mbs;
891 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
892 int last_slice = (endmb == (width_in_mbs * height_in_mbs));
894 unsigned char correct[6], grow, shrink;
896 int weighted_pred_idc = 0;
897 unsigned int luma_log2_weight_denom = slice_param->luma_log2_weight_denom;
898 unsigned int chroma_log2_weight_denom = slice_param->chroma_log2_weight_denom;
899 int num_ref_l0 = 0, num_ref_l1 = 0;
902 batch = encoder_context->base.batch;
904 if (slice_type == SLICE_TYPE_I) {
905 luma_log2_weight_denom = 0;
906 chroma_log2_weight_denom = 0;
907 } else if (slice_type == SLICE_TYPE_P) {
908 weighted_pred_idc = pic_param->pic_fields.bits.weighted_pred_flag;
909 num_ref_l0 = pic_param->num_ref_idx_l0_active_minus1 + 1;
911 if (slice_param->num_ref_idx_active_override_flag)
912 num_ref_l0 = slice_param->num_ref_idx_l0_active_minus1 + 1;
913 } else if (slice_type == SLICE_TYPE_B) {
914 weighted_pred_idc = pic_param->pic_fields.bits.weighted_bipred_idc;
915 num_ref_l0 = pic_param->num_ref_idx_l0_active_minus1 + 1;
916 num_ref_l1 = pic_param->num_ref_idx_l1_active_minus1 + 1;
918 if (slice_param->num_ref_idx_active_override_flag) {
919 num_ref_l0 = slice_param->num_ref_idx_l0_active_minus1 + 1;
920 num_ref_l1 = slice_param->num_ref_idx_l1_active_minus1 + 1;
923 if (weighted_pred_idc == 2) {
924 /* 8.4.3 - Derivation process for prediction weights (8-279) */
925 luma_log2_weight_denom = 5;
926 chroma_log2_weight_denom = 5;
930 maxQpN = mfc_context->bit_rate_control_context[slice_type].MaxQpNegModifier;
931 maxQpP = mfc_context->bit_rate_control_context[slice_type].MaxQpPosModifier;
933 for (i = 0; i < 6; i++)
934 correct[i] = mfc_context->bit_rate_control_context[slice_type].Correct[i];
936 grow = mfc_context->bit_rate_control_context[slice_type].GrowInit +
937 (mfc_context->bit_rate_control_context[slice_type].GrowResistance << 4);
938 shrink = mfc_context->bit_rate_control_context[slice_type].ShrinkInit +
939 (mfc_context->bit_rate_control_context[slice_type].ShrinkResistance << 4);
941 BEGIN_BCS_BATCH(batch, 11);;
943 OUT_BCS_BATCH(batch, MFX_AVC_SLICE_STATE | (11 - 2) );
944 OUT_BCS_BATCH(batch, slice_type); /*Slice Type: I:P:B Slice*/
949 (chroma_log2_weight_denom << 8) |
950 (luma_log2_weight_denom << 0));
953 (weighted_pred_idc << 30) |
954 (slice_param->direct_spatial_mv_pred_flag<<29) | /*Direct Prediction Type*/
955 (slice_param->disable_deblocking_filter_idc << 27) |
956 (slice_param->cabac_init_idc << 24) |
957 (qp<<16) | /*Slice Quantization Parameter*/
958 ((slice_param->slice_beta_offset_div2 & 0xf) << 8) |
959 ((slice_param->slice_alpha_c0_offset_div2 & 0xf) << 0));
961 (beginy << 24) | /*First MB X&Y , the begin postion of current slice*/
963 slice_param->macroblock_address );
964 OUT_BCS_BATCH(batch, (nexty << 16) | nextx); /*Next slice first MB X&Y*/
966 (0/*rate_control_enable*/ << 31) | /*in CBR mode RateControlCounterEnable = enable*/
967 (1 << 30) | /*ResetRateControlCounter*/
968 (0 << 28) | /*RC Triggle Mode = Always Rate Control*/
969 (4 << 24) | /*RC Stable Tolerance, middle level*/
970 (0/*rate_control_enable*/ << 23) | /*RC Panic Enable*/
971 (0 << 22) | /*QP mode, don't modfiy CBP*/
972 (0 << 21) | /*MB Type Direct Conversion Enabled*/
973 (0 << 20) | /*MB Type Skip Conversion Enabled*/
974 (last_slice << 19) | /*IsLastSlice*/
975 (0 << 18) | /*BitstreamOutputFlag Compressed BitStream Output Disable Flag 0:enable 1:disable*/
976 (1 << 17) | /*HeaderPresentFlag*/
977 (1 << 16) | /*SliceData PresentFlag*/
978 (1 << 15) | /*TailPresentFlag*/
979 (1 << 13) | /*RBSP NAL TYPE*/
980 (0 << 12) ); /*CabacZeroWordInsertionEnable*/
981 OUT_BCS_BATCH(batch, mfc_context->mfc_indirect_pak_bse_object.offset);
983 (maxQpN << 24) | /*Target QP - 24 is lowest QP*/
984 (maxQpP << 16) | /*Target QP + 20 is highest QP*/
994 OUT_BCS_BATCH(batch, 0);
996 ADVANCE_BCS_BATCH(batch);
1002 gen75_mfc_avc_pak_object_intra(VADriverContextP ctx, int x, int y, int end_mb,
1003 int qp,unsigned int *msg,
1004 struct intel_encoder_context *encoder_context,
1005 unsigned char target_mb_size, unsigned char max_mb_size,
1006 struct intel_batchbuffer *batch)
1008 int len_in_dwords = 12;
1009 unsigned int intra_msg;
1010 #define INTRA_MSG_FLAG (1 << 13)
1011 #define INTRA_MBTYPE_MASK (0x1F0000)
1013 batch = encoder_context->base.batch;
1015 BEGIN_BCS_BATCH(batch, len_in_dwords);
1017 intra_msg = msg[0] & 0xC0FF;
1018 intra_msg |= INTRA_MSG_FLAG;
1019 intra_msg |= ((msg[0] & INTRA_MBTYPE_MASK) >> 8);
1020 OUT_BCS_BATCH(batch, MFC_AVC_PAK_OBJECT | (len_in_dwords - 2));
1021 OUT_BCS_BATCH(batch, 0);
1022 OUT_BCS_BATCH(batch, 0);
1023 OUT_BCS_BATCH(batch,
1024 (0 << 24) | /* PackedMvNum, Debug*/
1025 (0 << 20) | /* No motion vector */
1026 (1 << 19) | /* CbpDcY */
1027 (1 << 18) | /* CbpDcU */
1028 (1 << 17) | /* CbpDcV */
1031 OUT_BCS_BATCH(batch, (0xFFFF << 16) | (y << 8) | x); /* Code Block Pattern for Y*/
1032 OUT_BCS_BATCH(batch, 0x000F000F); /* Code Block Pattern */
1033 OUT_BCS_BATCH(batch, (0 << 27) | (end_mb << 26) | qp); /* Last MB */
1035 /*Stuff for Intra MB*/
1036 OUT_BCS_BATCH(batch, msg[1]); /* We using Intra16x16 no 4x4 predmode*/
1037 OUT_BCS_BATCH(batch, msg[2]);
1038 OUT_BCS_BATCH(batch, msg[3]&0xFF);
1040 /*MaxSizeInWord and TargetSzieInWord*/
1041 OUT_BCS_BATCH(batch, (max_mb_size << 24) |
1042 (target_mb_size << 16) );
1044 OUT_BCS_BATCH(batch, 0);
1046 ADVANCE_BCS_BATCH(batch);
1048 return len_in_dwords;
1052 gen75_mfc_avc_pak_object_inter(VADriverContextP ctx, int x, int y, int end_mb, int qp,
1053 unsigned int *msg, unsigned int offset,
1054 struct intel_encoder_context *encoder_context,
1055 unsigned char target_mb_size,unsigned char max_mb_size, int slice_type,
1056 struct intel_batchbuffer *batch)
1058 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1059 int len_in_dwords = 12;
1060 unsigned int inter_msg = 0;
1062 batch = encoder_context->base.batch;
1064 #define MSG_MV_OFFSET 4
1065 unsigned int *mv_ptr;
1066 mv_ptr = msg + MSG_MV_OFFSET;
1067 /* MV of VME output is based on 16 sub-blocks. So it is necessary
1068 * to convert them to be compatible with the format of AVC_PAK
1071 if ((msg[0] & INTER_MODE_MASK) == INTER_8X16) {
1072 /* MV[0] and MV[2] are replicated */
1073 mv_ptr[4] = mv_ptr[0];
1074 mv_ptr[5] = mv_ptr[1];
1075 mv_ptr[2] = mv_ptr[8];
1076 mv_ptr[3] = mv_ptr[9];
1077 mv_ptr[6] = mv_ptr[8];
1078 mv_ptr[7] = mv_ptr[9];
1079 } else if ((msg[0] & INTER_MODE_MASK) == INTER_16X8) {
1080 /* MV[0] and MV[1] are replicated */
1081 mv_ptr[2] = mv_ptr[0];
1082 mv_ptr[3] = mv_ptr[1];
1083 mv_ptr[4] = mv_ptr[16];
1084 mv_ptr[5] = mv_ptr[17];
1085 mv_ptr[6] = mv_ptr[24];
1086 mv_ptr[7] = mv_ptr[25];
1087 } else if (((msg[0] & INTER_MODE_MASK) == INTER_8X8) &&
1088 !(msg[1] & SUBMB_SHAPE_MASK)) {
1089 /* Don't touch MV[0] or MV[1] */
1090 mv_ptr[2] = mv_ptr[8];
1091 mv_ptr[3] = mv_ptr[9];
1092 mv_ptr[4] = mv_ptr[16];
1093 mv_ptr[5] = mv_ptr[17];
1094 mv_ptr[6] = mv_ptr[24];
1095 mv_ptr[7] = mv_ptr[25];
1099 BEGIN_BCS_BATCH(batch, len_in_dwords);
1101 OUT_BCS_BATCH(batch, MFC_AVC_PAK_OBJECT | (len_in_dwords - 2));
1105 if ((msg[0] & INTER_MODE_MASK) == INTER_8X8) {
1106 if (msg[1] & SUBMB_SHAPE_MASK)
1109 OUT_BCS_BATCH(batch, inter_msg); /* 32 MV*/
1110 OUT_BCS_BATCH(batch, offset);
1111 inter_msg = msg[0] & (0x1F00FFFF);
1112 inter_msg |= INTER_MV8;
1113 inter_msg |= ((1 << 19) | (1 << 18) | (1 << 17));
1114 if (((msg[0] & INTER_MODE_MASK) == INTER_8X8) &&
1115 (msg[1] & SUBMB_SHAPE_MASK)) {
1116 inter_msg |= INTER_MV32;
1119 OUT_BCS_BATCH(batch, inter_msg);
1121 OUT_BCS_BATCH(batch, (0xFFFF<<16) | (y << 8) | x); /* Code Block Pattern for Y*/
1122 OUT_BCS_BATCH(batch, 0x000F000F); /* Code Block Pattern */
1124 if ( slice_type == SLICE_TYPE_B) {
1125 OUT_BCS_BATCH(batch, (0xF<<28) | (end_mb << 26) | qp); /* Last MB */
1127 OUT_BCS_BATCH(batch, (end_mb << 26) | qp); /* Last MB */
1130 OUT_BCS_BATCH(batch, (end_mb << 26) | qp); /* Last MB */
1133 inter_msg = msg[1] >> 8;
1134 /*Stuff for Inter MB*/
1135 OUT_BCS_BATCH(batch, inter_msg);
1136 OUT_BCS_BATCH(batch, vme_context->ref_index_in_mb[0]);
1137 OUT_BCS_BATCH(batch, vme_context->ref_index_in_mb[1]);
1139 /*MaxSizeInWord and TargetSzieInWord*/
1140 OUT_BCS_BATCH(batch, (max_mb_size << 24) |
1141 (target_mb_size << 16) );
1143 OUT_BCS_BATCH(batch, 0x0);
1145 ADVANCE_BCS_BATCH(batch);
1147 return len_in_dwords;
1151 gen75_mfc_avc_pipeline_slice_programing(VADriverContextP ctx,
1152 struct encode_state *encode_state,
1153 struct intel_encoder_context *encoder_context,
1155 struct intel_batchbuffer *slice_batch)
1157 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1158 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1159 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
1160 VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1161 VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[slice_index]->buffer;
1162 unsigned int *msg = NULL, offset = 0;
1163 unsigned char *msg_ptr = NULL;
1164 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
1165 int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
1166 int last_slice = (pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks) == (width_in_mbs * height_in_mbs);
1168 int qp = pPicParameter->pic_init_qp + pSliceParameter->slice_qp_delta;
1169 unsigned int rate_control_mode = encoder_context->rate_control_mode;
1170 unsigned int tail_data[] = { 0x0, 0x0 };
1171 int slice_type = intel_avc_enc_slice_type_fixup(pSliceParameter->slice_type);
1172 int is_intra = slice_type == SLICE_TYPE_I;
1177 if (rate_control_mode != VA_RC_CQP) {
1178 qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
1179 if (encode_state->slice_header_index[slice_index] == 0) {
1180 pSliceParameter->slice_qp_delta = qp - pPicParameter->pic_init_qp;
1185 /* only support for 8-bit pixel bit-depth */
1186 assert(pSequenceParameter->bit_depth_luma_minus8 == 0);
1187 assert(pSequenceParameter->bit_depth_chroma_minus8 == 0);
1188 assert(pPicParameter->pic_init_qp >= 0 && pPicParameter->pic_init_qp < 52);
1189 assert(qp >= 0 && qp < 52);
1191 gen75_mfc_avc_slice_state(ctx,
1194 encode_state, encoder_context,
1195 (rate_control_mode != VA_RC_CQP), qp_slice, slice_batch);
1197 if ( slice_index == 0)
1198 intel_mfc_avc_pipeline_header_programing(ctx, encode_state, encoder_context, slice_batch);
1200 intel_avc_slice_insert_packed_data(ctx, encode_state, encoder_context, slice_index, slice_batch);
1202 dri_bo_map(vme_context->vme_output.bo , 1);
1203 msg_ptr = (unsigned char *)vme_context->vme_output.bo->virtual;
1206 msg = (unsigned int *) (msg_ptr + pSliceParameter->macroblock_address * vme_context->vme_output.size_block);
1208 msg = (unsigned int *) (msg_ptr + pSliceParameter->macroblock_address * vme_context->vme_output.size_block);
1211 for (i = pSliceParameter->macroblock_address;
1212 i < pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks; i++) {
1213 int last_mb = (i == (pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks - 1) );
1214 x = i % width_in_mbs;
1215 y = i / width_in_mbs;
1216 msg = (unsigned int *) (msg_ptr + i * vme_context->vme_output.size_block);
1218 if (vme_context->roi_enabled) {
1219 qp_mb = *(vme_context->qp_per_mb + i);
1225 gen75_mfc_avc_pak_object_intra(ctx, x, y, last_mb, qp_mb, msg, encoder_context, 0, 0, slice_batch);
1227 int inter_rdo, intra_rdo;
1228 inter_rdo = msg[AVC_INTER_RDO_OFFSET] & AVC_RDO_MASK;
1229 intra_rdo = msg[AVC_INTRA_RDO_OFFSET] & AVC_RDO_MASK;
1230 offset = i * vme_context->vme_output.size_block + AVC_INTER_MV_OFFSET;
1231 if (intra_rdo < inter_rdo) {
1232 gen75_mfc_avc_pak_object_intra(ctx, x, y, last_mb, qp_mb, msg, encoder_context, 0, 0, slice_batch);
1234 msg += AVC_INTER_MSG_OFFSET;
1235 gen75_mfc_avc_pak_object_inter(ctx, x, y, last_mb, qp_mb,
1236 msg, offset, encoder_context,
1237 0, 0, slice_type, slice_batch);
1242 dri_bo_unmap(vme_context->vme_output.bo);
1245 mfc_context->insert_object(ctx, encoder_context,
1247 2, 1, 1, 0, slice_batch);
1249 mfc_context->insert_object(ctx, encoder_context,
1251 1, 1, 1, 0, slice_batch);
1256 gen75_mfc_avc_software_batchbuffer(VADriverContextP ctx,
1257 struct encode_state *encode_state,
1258 struct intel_encoder_context *encoder_context)
1260 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1261 struct intel_batchbuffer *batch;
1265 batch = mfc_context->aux_batchbuffer;
1266 batch_bo = batch->buffer;
1267 for (i = 0; i < encode_state->num_slice_params_ext; i++) {
1268 gen75_mfc_avc_pipeline_slice_programing(ctx, encode_state, encoder_context, i, batch);
1271 intel_batchbuffer_align(batch, 8);
1273 BEGIN_BCS_BATCH(batch, 2);
1274 OUT_BCS_BATCH(batch, 0);
1275 OUT_BCS_BATCH(batch, MI_BATCH_BUFFER_END);
1276 ADVANCE_BCS_BATCH(batch);
1278 dri_bo_reference(batch_bo);
1280 intel_batchbuffer_free(batch);
1281 mfc_context->aux_batchbuffer = NULL;
1288 gen75_mfc_batchbuffer_surfaces_input(VADriverContextP ctx,
1289 struct encode_state *encode_state,
1290 struct intel_encoder_context *encoder_context)
1293 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1294 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1296 assert(vme_context->vme_output.bo);
1297 mfc_context->buffer_suface_setup(ctx,
1298 &mfc_context->gpe_context,
1299 &vme_context->vme_output,
1300 BINDING_TABLE_OFFSET(BIND_IDX_VME_OUTPUT),
1301 SURFACE_STATE_OFFSET(BIND_IDX_VME_OUTPUT));
1305 gen75_mfc_batchbuffer_surfaces_output(VADriverContextP ctx,
1306 struct encode_state *encode_state,
1307 struct intel_encoder_context *encoder_context)
1310 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1311 assert(mfc_context->aux_batchbuffer_surface.bo);
1312 mfc_context->buffer_suface_setup(ctx,
1313 &mfc_context->gpe_context,
1314 &mfc_context->aux_batchbuffer_surface,
1315 BINDING_TABLE_OFFSET(BIND_IDX_MFC_BATCHBUFFER),
1316 SURFACE_STATE_OFFSET(BIND_IDX_MFC_BATCHBUFFER));
1320 gen75_mfc_batchbuffer_surfaces_setup(VADriverContextP ctx,
1321 struct encode_state *encode_state,
1322 struct intel_encoder_context *encoder_context)
1324 gen75_mfc_batchbuffer_surfaces_input(ctx, encode_state, encoder_context);
1325 gen75_mfc_batchbuffer_surfaces_output(ctx, encode_state, encoder_context);
1329 gen75_mfc_batchbuffer_idrt_setup(VADriverContextP ctx,
1330 struct encode_state *encode_state,
1331 struct intel_encoder_context *encoder_context)
1333 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1334 struct gen6_interface_descriptor_data *desc;
1338 bo = mfc_context->gpe_context.idrt.bo;
1340 assert(bo->virtual);
1343 for (i = 0; i < mfc_context->gpe_context.num_kernels; i++) {
1344 struct i965_kernel *kernel;
1346 kernel = &mfc_context->gpe_context.kernels[i];
1347 assert(sizeof(*desc) == 32);
1349 /*Setup the descritor table*/
1350 memset(desc, 0, sizeof(*desc));
1351 desc->desc0.kernel_start_pointer = (kernel->bo->offset >> 6);
1352 desc->desc2.sampler_count = 0;
1353 desc->desc2.sampler_state_pointer = 0;
1354 desc->desc3.binding_table_entry_count = 2;
1355 desc->desc3.binding_table_pointer = (BINDING_TABLE_OFFSET(0) >> 5);
1356 desc->desc4.constant_urb_entry_read_offset = 0;
1357 desc->desc4.constant_urb_entry_read_length = 4;
1360 dri_bo_emit_reloc(bo,
1361 I915_GEM_DOMAIN_INSTRUCTION, 0,
1363 i * sizeof(*desc) + offsetof(struct gen6_interface_descriptor_data, desc0),
1372 gen75_mfc_batchbuffer_constant_setup(VADriverContextP ctx,
1373 struct encode_state *encode_state,
1374 struct intel_encoder_context *encoder_context)
1376 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1381 #define AVC_PAK_LEN_IN_BYTE 48
1382 #define AVC_PAK_LEN_IN_OWORD 3
1385 gen75_mfc_batchbuffer_emit_object_command(struct intel_batchbuffer *batch,
1386 uint32_t intra_flag,
1398 uint32_t temp_value;
1399 BEGIN_BATCH(batch, 14);
1401 OUT_BATCH(batch, CMD_MEDIA_OBJECT | (14 - 2));
1402 OUT_BATCH(batch, 0);
1403 OUT_BATCH(batch, 0);
1404 OUT_BATCH(batch, 0);
1405 OUT_BATCH(batch, 0);
1406 OUT_BATCH(batch, 0);
1409 OUT_BATCH(batch, head_offset / 16);
1410 OUT_BATCH(batch, (intra_flag) | (qp << 16));
1411 temp_value = (mb_x | (mb_y << 8) | (width_in_mbs << 16));
1412 OUT_BATCH(batch, temp_value);
1414 OUT_BATCH(batch, number_mb_cmds);
1417 ((slice_end_y << 8) | (slice_end_x)));
1418 OUT_BATCH(batch, fwd_ref);
1419 OUT_BATCH(batch, bwd_ref);
1421 OUT_BATCH(batch, MI_NOOP);
1423 ADVANCE_BATCH(batch);
1427 gen75_mfc_avc_batchbuffer_slice_command(VADriverContextP ctx,
1428 struct intel_encoder_context *encoder_context,
1429 VAEncSliceParameterBufferH264 *slice_param,
1434 struct intel_batchbuffer *batch = encoder_context->base.batch;
1435 struct gen6_vme_context *vme_context = encoder_context->vme_context;
1436 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1437 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
1438 int total_mbs = slice_param->num_macroblocks;
1439 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1440 int number_mb_cmds = 128;
1441 int starting_offset = 0;
1443 int last_mb, slice_end_x, slice_end_y;
1444 int remaining_mb = total_mbs;
1445 uint32_t fwd_ref , bwd_ref, mb_flag;
1447 last_mb = slice_param->macroblock_address + total_mbs - 1;
1448 slice_end_x = last_mb % width_in_mbs;
1449 slice_end_y = last_mb / width_in_mbs;
1451 if (slice_type == SLICE_TYPE_I) {
1456 fwd_ref = vme_context->ref_index_in_mb[0];
1457 bwd_ref = vme_context->ref_index_in_mb[1];
1461 if (width_in_mbs >= 100) {
1462 number_mb_cmds = width_in_mbs / 5;
1463 } else if (width_in_mbs >= 80) {
1464 number_mb_cmds = width_in_mbs / 4;
1465 } else if (width_in_mbs >= 60) {
1466 number_mb_cmds = width_in_mbs / 3;
1467 } else if (width_in_mbs >= 40) {
1468 number_mb_cmds = width_in_mbs / 2;
1470 number_mb_cmds = width_in_mbs;
1474 if (number_mb_cmds >= remaining_mb) {
1475 number_mb_cmds = remaining_mb;
1477 mb_x = (slice_param->macroblock_address + starting_offset) % width_in_mbs;
1478 mb_y = (slice_param->macroblock_address + starting_offset) / width_in_mbs;
1480 gen75_mfc_batchbuffer_emit_object_command(batch,
1493 head_offset += (number_mb_cmds * AVC_PAK_LEN_IN_BYTE);
1494 remaining_mb -= number_mb_cmds;
1495 starting_offset += number_mb_cmds;
1496 } while (remaining_mb > 0);
1500 * return size in Owords (16bytes)
1503 gen75_mfc_avc_batchbuffer_slice(VADriverContextP ctx,
1504 struct encode_state *encode_state,
1505 struct intel_encoder_context *encoder_context,
1508 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1509 struct intel_batchbuffer *slice_batch = mfc_context->aux_batchbuffer;
1510 VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
1511 VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1512 VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[slice_index]->buffer;
1513 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
1514 int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
1515 int last_slice = (pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks) == (width_in_mbs * height_in_mbs);
1516 int qp = pPicParameter->pic_init_qp + pSliceParameter->slice_qp_delta;
1517 unsigned int rate_control_mode = encoder_context->rate_control_mode;
1518 unsigned int tail_data[] = { 0x0, 0x0 };
1520 int slice_type = intel_avc_enc_slice_type_fixup(pSliceParameter->slice_type);
1524 if (rate_control_mode != VA_RC_CQP) {
1525 qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
1526 if (encode_state->slice_header_index[slice_index] == 0) {
1527 pSliceParameter->slice_qp_delta = qp - pPicParameter->pic_init_qp;
1532 /* only support for 8-bit pixel bit-depth */
1533 assert(pSequenceParameter->bit_depth_luma_minus8 == 0);
1534 assert(pSequenceParameter->bit_depth_chroma_minus8 == 0);
1535 assert(pPicParameter->pic_init_qp >= 0 && pPicParameter->pic_init_qp < 52);
1536 assert(qp >= 0 && qp < 52);
1538 gen75_mfc_avc_slice_state(ctx,
1543 (rate_control_mode != VA_RC_CQP),
1547 if (slice_index == 0)
1548 intel_mfc_avc_pipeline_header_programing(ctx, encode_state, encoder_context, slice_batch);
1550 intel_avc_slice_insert_packed_data(ctx, encode_state, encoder_context, slice_index, slice_batch);
1552 intel_batchbuffer_align(slice_batch, 16); /* aligned by an Oword */
1553 head_offset = intel_batchbuffer_used_size(slice_batch);
1555 slice_batch->ptr += pSliceParameter->num_macroblocks * AVC_PAK_LEN_IN_BYTE;
1557 gen75_mfc_avc_batchbuffer_slice_command(ctx,
1565 /* Aligned for tail */
1566 intel_batchbuffer_align(slice_batch, 16); /* aligned by an Oword */
1568 mfc_context->insert_object(ctx,
1579 mfc_context->insert_object(ctx,
1595 gen75_mfc_avc_batchbuffer_pipeline(VADriverContextP ctx,
1596 struct encode_state *encode_state,
1597 struct intel_encoder_context *encoder_context)
1599 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1600 struct intel_batchbuffer *batch = encoder_context->base.batch;
1602 intel_batchbuffer_start_atomic(batch, 0x4000);
1603 gen6_gpe_pipeline_setup(ctx, &mfc_context->gpe_context, batch);
1605 for ( i = 0; i < encode_state->num_slice_params_ext; i++) {
1606 gen75_mfc_avc_batchbuffer_slice(ctx, encode_state, encoder_context, i);
1609 struct intel_batchbuffer *slice_batch = mfc_context->aux_batchbuffer;
1610 intel_batchbuffer_align(slice_batch, 8);
1611 BEGIN_BCS_BATCH(slice_batch, 2);
1612 OUT_BCS_BATCH(slice_batch, 0);
1613 OUT_BCS_BATCH(slice_batch, MI_BATCH_BUFFER_END);
1614 ADVANCE_BCS_BATCH(slice_batch);
1615 mfc_context->aux_batchbuffer = NULL;
1616 intel_batchbuffer_free(slice_batch);
1618 intel_batchbuffer_end_atomic(batch);
1619 intel_batchbuffer_flush(batch);
1623 gen75_mfc_build_avc_batchbuffer(VADriverContextP ctx,
1624 struct encode_state *encode_state,
1625 struct intel_encoder_context *encoder_context)
1627 gen75_mfc_batchbuffer_surfaces_setup(ctx, encode_state, encoder_context);
1628 gen75_mfc_batchbuffer_idrt_setup(ctx, encode_state, encoder_context);
1629 gen75_mfc_batchbuffer_constant_setup(ctx, encode_state, encoder_context);
1630 gen75_mfc_avc_batchbuffer_pipeline(ctx, encode_state, encoder_context);
1634 gen75_mfc_avc_hardware_batchbuffer(VADriverContextP ctx,
1635 struct encode_state *encode_state,
1636 struct intel_encoder_context *encoder_context)
1638 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1640 dri_bo_reference(mfc_context->aux_batchbuffer_surface.bo);
1641 gen75_mfc_build_avc_batchbuffer(ctx, encode_state, encoder_context);
1643 return mfc_context->aux_batchbuffer_surface.bo;
1648 gen75_mfc_avc_pipeline_programing(VADriverContextP ctx,
1649 struct encode_state *encode_state,
1650 struct intel_encoder_context *encoder_context)
1652 struct intel_batchbuffer *batch = encoder_context->base.batch;
1653 dri_bo *slice_batch_bo;
1655 if ( intel_mfc_interlace_check(ctx, encode_state, encoder_context) ) {
1656 fprintf(stderr, "Current VA driver don't support interlace mode!\n");
1662 if (encoder_context->soft_batch_force)
1663 slice_batch_bo = gen75_mfc_avc_software_batchbuffer(ctx, encode_state, encoder_context);
1665 slice_batch_bo = gen75_mfc_avc_hardware_batchbuffer(ctx, encode_state, encoder_context);
1668 intel_batchbuffer_start_atomic_bcs(batch, 0x4000);
1669 intel_batchbuffer_emit_mi_flush(batch);
1671 // picture level programing
1672 gen75_mfc_avc_pipeline_picture_programing(ctx, encode_state, encoder_context);
1674 BEGIN_BCS_BATCH(batch, 2);
1675 OUT_BCS_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8));
1676 OUT_BCS_RELOC(batch,
1678 I915_GEM_DOMAIN_COMMAND, 0,
1680 ADVANCE_BCS_BATCH(batch);
1683 intel_batchbuffer_end_atomic(batch);
1685 dri_bo_unreference(slice_batch_bo);
1690 gen75_mfc_avc_encode_picture(VADriverContextP ctx,
1691 struct encode_state *encode_state,
1692 struct intel_encoder_context *encoder_context)
1694 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1695 unsigned int rate_control_mode = encoder_context->rate_control_mode;
1696 int current_frame_bits_size;
1700 gen75_mfc_init(ctx, encode_state, encoder_context);
1701 intel_mfc_avc_prepare(ctx, encode_state, encoder_context);
1702 /*Programing bcs pipeline*/
1703 gen75_mfc_avc_pipeline_programing(ctx, encode_state, encoder_context); //filling the pipeline
1704 gen75_mfc_run(ctx, encode_state, encoder_context);
1705 if (rate_control_mode == VA_RC_CBR || rate_control_mode == VA_RC_VBR) {
1706 gen75_mfc_stop(ctx, encode_state, encoder_context, ¤t_frame_bits_size);
1707 sts = intel_mfc_brc_postpack(encode_state, encoder_context, current_frame_bits_size);
1708 if (sts == BRC_NO_HRD_VIOLATION) {
1709 intel_mfc_hrd_context_update(encode_state, mfc_context);
1712 else if (sts == BRC_OVERFLOW_WITH_MIN_QP || sts == BRC_UNDERFLOW_WITH_MAX_QP) {
1713 if (!mfc_context->hrd.violation_noted) {
1714 fprintf(stderr, "Unrepairable %s!\n", (sts == BRC_OVERFLOW_WITH_MIN_QP)? "overflow": "underflow");
1715 mfc_context->hrd.violation_noted = 1;
1717 return VA_STATUS_SUCCESS;
1724 return VA_STATUS_SUCCESS;
1732 va_to_gen75_mpeg2_picture_type[3] = {
1739 gen75_mfc_mpeg2_pic_state(VADriverContextP ctx,
1740 struct intel_encoder_context *encoder_context,
1741 struct encode_state *encode_state)
1743 struct intel_batchbuffer *batch = encoder_context->base.batch;
1744 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1745 VAEncPictureParameterBufferMPEG2 *pic_param;
1746 int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
1747 int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
1748 VAEncSliceParameterBufferMPEG2 *slice_param = NULL;
1750 assert(encode_state->pic_param_ext && encode_state->pic_param_ext->buffer);
1751 pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
1752 slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[0]->buffer;
1754 BEGIN_BCS_BATCH(batch, 13);
1755 OUT_BCS_BATCH(batch, MFX_MPEG2_PIC_STATE | (13 - 2));
1756 OUT_BCS_BATCH(batch,
1757 (pic_param->f_code[1][1] & 0xf) << 28 | /* f_code[1][1] */
1758 (pic_param->f_code[1][0] & 0xf) << 24 | /* f_code[1][0] */
1759 (pic_param->f_code[0][1] & 0xf) << 20 | /* f_code[0][1] */
1760 (pic_param->f_code[0][0] & 0xf) << 16 | /* f_code[0][0] */
1761 pic_param->picture_coding_extension.bits.intra_dc_precision << 14 |
1762 pic_param->picture_coding_extension.bits.picture_structure << 12 |
1763 pic_param->picture_coding_extension.bits.top_field_first << 11 |
1764 pic_param->picture_coding_extension.bits.frame_pred_frame_dct << 10 |
1765 pic_param->picture_coding_extension.bits.concealment_motion_vectors << 9 |
1766 pic_param->picture_coding_extension.bits.q_scale_type << 8 |
1767 pic_param->picture_coding_extension.bits.intra_vlc_format << 7 |
1768 pic_param->picture_coding_extension.bits.alternate_scan << 6);
1769 OUT_BCS_BATCH(batch,
1770 0 << 14 | /* LoadSlicePointerFlag, 0 means only loading bitstream pointer once */
1771 va_to_gen75_mpeg2_picture_type[pic_param->picture_type] << 9 |
1773 OUT_BCS_BATCH(batch,
1774 1 << 31 | /* slice concealment */
1775 (height_in_mbs - 1) << 16 |
1776 (width_in_mbs - 1));
1777 if (slice_param && slice_param->quantiser_scale_code >= 14)
1778 OUT_BCS_BATCH(batch, (3 << 1) | (1 << 4) | (5 << 8) | (1 << 12));
1780 OUT_BCS_BATCH(batch, 0);
1782 OUT_BCS_BATCH(batch, 0);
1783 OUT_BCS_BATCH(batch,
1784 0xFFF << 16 | /* InterMBMaxSize */
1785 0xFFF << 0 | /* IntraMBMaxSize */
1787 OUT_BCS_BATCH(batch, 0);
1788 OUT_BCS_BATCH(batch, 0);
1789 OUT_BCS_BATCH(batch, 0);
1790 OUT_BCS_BATCH(batch, 0);
1791 OUT_BCS_BATCH(batch, 0);
1792 OUT_BCS_BATCH(batch, 0);
1793 ADVANCE_BCS_BATCH(batch);
1797 gen75_mfc_mpeg2_qm_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
1799 unsigned char intra_qm[64] = {
1800 8, 16, 19, 22, 26, 27, 29, 34,
1801 16, 16, 22, 24, 27, 29, 34, 37,
1802 19, 22, 26, 27, 29, 34, 34, 38,
1803 22, 22, 26, 27, 29, 34, 37, 40,
1804 22, 26, 27, 29, 32, 35, 40, 48,
1805 26, 27, 29, 32, 35, 40, 48, 58,
1806 26, 27, 29, 34, 38, 46, 56, 69,
1807 27, 29, 35, 38, 46, 56, 69, 83
1810 unsigned char non_intra_qm[64] = {
1811 16, 16, 16, 16, 16, 16, 16, 16,
1812 16, 16, 16, 16, 16, 16, 16, 16,
1813 16, 16, 16, 16, 16, 16, 16, 16,
1814 16, 16, 16, 16, 16, 16, 16, 16,
1815 16, 16, 16, 16, 16, 16, 16, 16,
1816 16, 16, 16, 16, 16, 16, 16, 16,
1817 16, 16, 16, 16, 16, 16, 16, 16,
1818 16, 16, 16, 16, 16, 16, 16, 16
1821 gen75_mfc_qm_state(ctx, MFX_QM_MPEG_INTRA_QUANTIZER_MATRIX, (unsigned int *)intra_qm, 16, encoder_context);
1822 gen75_mfc_qm_state(ctx, MFX_QM_MPEG_NON_INTRA_QUANTIZER_MATRIX, (unsigned int *)non_intra_qm, 16,encoder_context);
1826 gen75_mfc_mpeg2_fqm_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
1828 unsigned short intra_fqm[64] = {
1829 65536/0x8, 65536/0x10, 65536/0x13, 65536/0x16, 65536/0x16, 65536/0x1a, 65536/0x1a, 65536/0x1b,
1830 65536/0x10, 65536/0x10, 65536/0x16, 65536/0x16, 65536/0x1a, 65536/0x1b, 65536/0x1b, 65536/0x1d,
1831 65536/0x13, 65536/0x16, 65536/0x1a, 65536/0x1a, 65536/0x1b, 65536/0x1d, 65536/0x1d, 65536/0x23,
1832 65536/0x16, 65536/0x18, 65536/0x1b, 65536/0x1b, 65536/0x13, 65536/0x20, 65536/0x22, 65536/0x26,
1833 65536/0x1a, 65536/0x1b, 65536/0x13, 65536/0x13, 65536/0x20, 65536/0x23, 65536/0x26, 65536/0x2e,
1834 65536/0x1b, 65536/0x1d, 65536/0x22, 65536/0x22, 65536/0x23, 65536/0x28, 65536/0x2e, 65536/0x38,
1835 65536/0x1d, 65536/0x22, 65536/0x22, 65536/0x25, 65536/0x28, 65536/0x30, 65536/0x38, 65536/0x45,
1836 65536/0x22, 65536/0x25, 65536/0x26, 65536/0x28, 65536/0x30, 65536/0x3a, 65536/0x45, 65536/0x53,
1839 unsigned short non_intra_fqm[64] = {
1840 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1841 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1842 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1843 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1844 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1845 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1846 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1847 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
1850 gen75_mfc_fqm_state(ctx, MFX_QM_MPEG_INTRA_QUANTIZER_MATRIX, (unsigned int *)intra_fqm, 32, encoder_context);
1851 gen75_mfc_fqm_state(ctx, MFX_QM_MPEG_NON_INTRA_QUANTIZER_MATRIX, (unsigned int *)non_intra_fqm, 32, encoder_context);
1855 gen75_mfc_mpeg2_slicegroup_state(VADriverContextP ctx,
1856 struct intel_encoder_context *encoder_context,
1858 int next_x, int next_y,
1859 int is_fisrt_slice_group,
1860 int is_last_slice_group,
1863 struct intel_batchbuffer *batch)
1865 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1868 batch = encoder_context->base.batch;
1870 BEGIN_BCS_BATCH(batch, 8);
1872 OUT_BCS_BATCH(batch, MFC_MPEG2_SLICEGROUP_STATE | (8 - 2));
1873 OUT_BCS_BATCH(batch,
1874 0 << 31 | /* MbRateCtrlFlag */
1875 !!is_last_slice_group << 19 | /* IsLastSliceGrp */
1876 1 << 17 | /* Insert Header before the first slice group data */
1877 1 << 16 | /* SliceData PresentFlag: always 1 */
1878 1 << 15 | /* TailPresentFlag: always 1 */
1879 0 << 14 | /* FirstSliceHdrDisabled: slice header for each slice */
1880 !!intra_slice << 13 | /* IntraSlice */
1881 !!intra_slice << 12 | /* IntraSliceFlag */
1883 OUT_BCS_BATCH(batch,
1889 OUT_BCS_BATCH(batch, qp); /* FIXME: SliceGroupQp */
1890 /* bitstream pointer is only loaded once for the first slice of a frame when
1891 * LoadSlicePointerFlag is 0
1893 OUT_BCS_BATCH(batch, mfc_context->mfc_indirect_pak_bse_object.offset);
1894 OUT_BCS_BATCH(batch, 0); /* FIXME: */
1895 OUT_BCS_BATCH(batch, 0); /* FIXME: CorrectPoints */
1896 OUT_BCS_BATCH(batch, 0); /* FIXME: CVxxx */
1898 ADVANCE_BCS_BATCH(batch);
1902 gen75_mfc_mpeg2_pak_object_intra(VADriverContextP ctx,
1903 struct intel_encoder_context *encoder_context,
1905 int first_mb_in_slice,
1906 int last_mb_in_slice,
1907 int first_mb_in_slice_group,
1908 int last_mb_in_slice_group,
1911 int coded_block_pattern,
1912 unsigned char target_size_in_word,
1913 unsigned char max_size_in_word,
1914 struct intel_batchbuffer *batch)
1916 int len_in_dwords = 9;
1919 batch = encoder_context->base.batch;
1921 BEGIN_BCS_BATCH(batch, len_in_dwords);
1923 OUT_BCS_BATCH(batch, MFC_MPEG2_PAK_OBJECT | (len_in_dwords - 2));
1924 OUT_BCS_BATCH(batch,
1925 0 << 24 | /* PackedMvNum */
1926 0 << 20 | /* MvFormat */
1927 7 << 17 | /* CbpDcY/CbpDcU/CbpDcV */
1928 0 << 15 | /* TransformFlag: frame DCT */
1929 0 << 14 | /* FieldMbFlag */
1930 1 << 13 | /* IntraMbFlag */
1931 mb_type << 8 | /* MbType: Intra */
1932 0 << 2 | /* SkipMbFlag */
1933 0 << 0 | /* InterMbMode */
1935 OUT_BCS_BATCH(batch, y << 16 | x);
1936 OUT_BCS_BATCH(batch,
1937 max_size_in_word << 24 |
1938 target_size_in_word << 16 |
1939 coded_block_pattern << 6 | /* CBP */
1941 OUT_BCS_BATCH(batch,
1942 last_mb_in_slice << 31 |
1943 first_mb_in_slice << 30 |
1944 0 << 27 | /* EnableCoeffClamp */
1945 last_mb_in_slice_group << 26 |
1946 0 << 25 | /* MbSkipConvDisable */
1947 first_mb_in_slice_group << 24 |
1948 0 << 16 | /* MvFieldSelect */
1949 qp_scale_code << 0 |
1951 OUT_BCS_BATCH(batch, 0); /* MV[0][0] */
1952 OUT_BCS_BATCH(batch, 0); /* MV[1][0] */
1953 OUT_BCS_BATCH(batch, 0); /* MV[0][1] */
1954 OUT_BCS_BATCH(batch, 0); /* MV[1][1] */
1956 ADVANCE_BCS_BATCH(batch);
1958 return len_in_dwords;
1961 #define MPEG2_INTER_MV_OFFSET 12
1963 static struct _mv_ranges
1965 int low; /* in the unit of 1/2 pixel */
1966 int high; /* in the unit of 1/2 pixel */
1981 mpeg2_motion_vector(int mv, int pos, int display_max, int f_code)
1983 if (mv + pos * 16 * 2 < 0 ||
1984 mv + (pos + 1) * 16 * 2 > display_max * 2)
1987 if (f_code > 0 && f_code < 10) {
1988 if (mv < mv_ranges[f_code].low)
1989 mv = mv_ranges[f_code].low;
1991 if (mv > mv_ranges[f_code].high)
1992 mv = mv_ranges[f_code].high;
1999 gen75_mfc_mpeg2_pak_object_inter(VADriverContextP ctx,
2000 struct encode_state *encode_state,
2001 struct intel_encoder_context *encoder_context,
2003 int width_in_mbs, int height_in_mbs,
2005 int first_mb_in_slice,
2006 int last_mb_in_slice,
2007 int first_mb_in_slice_group,
2008 int last_mb_in_slice_group,
2010 unsigned char target_size_in_word,
2011 unsigned char max_size_in_word,
2012 struct intel_batchbuffer *batch)
2014 VAEncPictureParameterBufferMPEG2 *pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
2015 int len_in_dwords = 9;
2016 short *mvptr, mvx0, mvy0, mvx1, mvy1;
2019 batch = encoder_context->base.batch;
2021 mvptr = (short *)(msg + MPEG2_INTER_MV_OFFSET);
2022 mvx0 = mpeg2_motion_vector(mvptr[0] / 2, x, width_in_mbs * 16, pic_param->f_code[0][0]);
2023 mvy0 = mpeg2_motion_vector(mvptr[1] / 2, y, height_in_mbs * 16, pic_param->f_code[0][0]);
2024 mvx1 = mpeg2_motion_vector(mvptr[2] / 2, x, width_in_mbs * 16, pic_param->f_code[1][0]);
2025 mvy1 = mpeg2_motion_vector(mvptr[3] / 2, y, height_in_mbs * 16, pic_param->f_code[1][0]);
2027 BEGIN_BCS_BATCH(batch, len_in_dwords);
2029 OUT_BCS_BATCH(batch, MFC_MPEG2_PAK_OBJECT | (len_in_dwords - 2));
2030 OUT_BCS_BATCH(batch,
2031 2 << 24 | /* PackedMvNum */
2032 7 << 20 | /* MvFormat */
2033 7 << 17 | /* CbpDcY/CbpDcU/CbpDcV */
2034 0 << 15 | /* TransformFlag: frame DCT */
2035 0 << 14 | /* FieldMbFlag */
2036 0 << 13 | /* IntraMbFlag */
2037 1 << 8 | /* MbType: Frame-based */
2038 0 << 2 | /* SkipMbFlag */
2039 0 << 0 | /* InterMbMode */
2041 OUT_BCS_BATCH(batch, y << 16 | x);
2042 OUT_BCS_BATCH(batch,
2043 max_size_in_word << 24 |
2044 target_size_in_word << 16 |
2045 0x3f << 6 | /* CBP */
2047 OUT_BCS_BATCH(batch,
2048 last_mb_in_slice << 31 |
2049 first_mb_in_slice << 30 |
2050 0 << 27 | /* EnableCoeffClamp */
2051 last_mb_in_slice_group << 26 |
2052 0 << 25 | /* MbSkipConvDisable */
2053 first_mb_in_slice_group << 24 |
2054 0 << 16 | /* MvFieldSelect */
2055 qp_scale_code << 0 |
2058 OUT_BCS_BATCH(batch, (mvx0 & 0xFFFF) | mvy0 << 16); /* MV[0][0] */
2059 OUT_BCS_BATCH(batch, (mvx1 & 0xFFFF) | mvy1 << 16); /* MV[1][0] */
2060 OUT_BCS_BATCH(batch, 0); /* MV[0][1] */
2061 OUT_BCS_BATCH(batch, 0); /* MV[1][1] */
2063 ADVANCE_BCS_BATCH(batch);
2065 return len_in_dwords;
2069 intel_mfc_mpeg2_pipeline_header_programing(VADriverContextP ctx,
2070 struct encode_state *encode_state,
2071 struct intel_encoder_context *encoder_context,
2072 struct intel_batchbuffer *slice_batch)
2074 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2075 int idx = va_enc_packed_type_to_idx(VAEncPackedHeaderMPEG2_SPS);
2077 if (encode_state->packed_header_data[idx]) {
2078 VAEncPackedHeaderParameterBuffer *param = NULL;
2079 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
2080 unsigned int length_in_bits;
2082 assert(encode_state->packed_header_param[idx]);
2083 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
2084 length_in_bits = param->bit_length;
2086 mfc_context->insert_object(ctx,
2089 ALIGN(length_in_bits, 32) >> 5,
2090 length_in_bits & 0x1f,
2091 5, /* FIXME: check it */
2094 0, /* Needn't insert emulation bytes for MPEG-2 */
2098 idx = va_enc_packed_type_to_idx(VAEncPackedHeaderMPEG2_PPS);
2100 if (encode_state->packed_header_data[idx]) {
2101 VAEncPackedHeaderParameterBuffer *param = NULL;
2102 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
2103 unsigned int length_in_bits;
2105 assert(encode_state->packed_header_param[idx]);
2106 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
2107 length_in_bits = param->bit_length;
2109 mfc_context->insert_object(ctx,
2112 ALIGN(length_in_bits, 32) >> 5,
2113 length_in_bits & 0x1f,
2114 5, /* FIXME: check it */
2117 0, /* Needn't insert emulation bytes for MPEG-2 */
2123 gen75_mfc_mpeg2_pipeline_slice_group(VADriverContextP ctx,
2124 struct encode_state *encode_state,
2125 struct intel_encoder_context *encoder_context,
2127 VAEncSliceParameterBufferMPEG2 *next_slice_group_param,
2128 struct intel_batchbuffer *slice_batch)
2130 struct gen6_vme_context *vme_context = encoder_context->vme_context;
2131 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2132 VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
2133 VAEncSliceParameterBufferMPEG2 *slice_param = NULL;
2134 unsigned char tail_delimiter[] = {MPEG2_DELIMITER0, MPEG2_DELIMITER1, MPEG2_DELIMITER2, MPEG2_DELIMITER3, MPEG2_DELIMITER4, 0, 0, 0};
2135 unsigned char section_delimiter[] = {0x0, 0x0, 0x0, 0x0};
2136 int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
2137 int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
2139 int h_start_pos, v_start_pos, h_next_start_pos, v_next_start_pos;
2140 unsigned int *msg = NULL;
2141 unsigned char *msg_ptr = NULL;
2143 slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[slice_index]->buffer;
2144 h_start_pos = slice_param->macroblock_address % width_in_mbs;
2145 v_start_pos = slice_param->macroblock_address / width_in_mbs;
2146 assert(h_start_pos + slice_param->num_macroblocks <= width_in_mbs);
2148 dri_bo_map(vme_context->vme_output.bo , 0);
2149 msg_ptr = (unsigned char *)vme_context->vme_output.bo->virtual;
2151 if (next_slice_group_param) {
2152 h_next_start_pos = next_slice_group_param->macroblock_address % width_in_mbs;
2153 v_next_start_pos = next_slice_group_param->macroblock_address / width_in_mbs;
2155 h_next_start_pos = 0;
2156 v_next_start_pos = height_in_mbs;
2159 gen75_mfc_mpeg2_slicegroup_state(ctx,
2166 next_slice_group_param == NULL,
2167 slice_param->is_intra_slice,
2168 slice_param->quantiser_scale_code,
2171 if (slice_index == 0)
2172 intel_mfc_mpeg2_pipeline_header_programing(ctx, encode_state, encoder_context, slice_batch);
2174 /* Insert '00' to make sure the header is valid */
2175 mfc_context->insert_object(ctx,
2177 (unsigned int*)section_delimiter,
2179 8, /* 8bits in the last DWORD */
2186 for (i = 0; i < encode_state->slice_params_ext[slice_index]->num_elements; i++) {
2187 /* PAK for each macroblocks */
2188 for (j = 0; j < slice_param->num_macroblocks; j++) {
2189 int h_pos = (slice_param->macroblock_address + j) % width_in_mbs;
2190 int v_pos = (slice_param->macroblock_address + j) / width_in_mbs;
2191 int first_mb_in_slice = (j == 0);
2192 int last_mb_in_slice = (j == slice_param->num_macroblocks - 1);
2193 int first_mb_in_slice_group = (i == 0 && j == 0);
2194 int last_mb_in_slice_group = (i == encode_state->slice_params_ext[slice_index]->num_elements - 1 &&
2195 j == slice_param->num_macroblocks - 1);
2197 msg = (unsigned int *)(msg_ptr + (slice_param->macroblock_address + j) * vme_context->vme_output.size_block);
2199 if (slice_param->is_intra_slice) {
2200 gen75_mfc_mpeg2_pak_object_intra(ctx,
2205 first_mb_in_slice_group,
2206 last_mb_in_slice_group,
2208 slice_param->quantiser_scale_code,
2214 int inter_rdo, intra_rdo;
2215 inter_rdo = msg[AVC_INTER_RDO_OFFSET] & AVC_RDO_MASK;
2216 intra_rdo = msg[AVC_INTRA_RDO_OFFSET] & AVC_RDO_MASK;
2218 if (intra_rdo < inter_rdo)
2219 gen75_mfc_mpeg2_pak_object_intra(ctx,
2224 first_mb_in_slice_group,
2225 last_mb_in_slice_group,
2227 slice_param->quantiser_scale_code,
2233 gen75_mfc_mpeg2_pak_object_inter(ctx,
2237 width_in_mbs, height_in_mbs,
2241 first_mb_in_slice_group,
2242 last_mb_in_slice_group,
2243 slice_param->quantiser_scale_code,
2253 dri_bo_unmap(vme_context->vme_output.bo);
2256 if (next_slice_group_param == NULL) { /* end of a picture */
2257 mfc_context->insert_object(ctx,
2259 (unsigned int *)tail_delimiter,
2261 8, /* 8bits in the last DWORD */
2267 } else { /* end of a lsice group */
2268 mfc_context->insert_object(ctx,
2270 (unsigned int *)section_delimiter,
2272 8, /* 8bits in the last DWORD */
2282 * A batch buffer for all slices, including slice state,
2283 * slice insert object and slice pak object commands
2287 gen75_mfc_mpeg2_software_slice_batchbuffer(VADriverContextP ctx,
2288 struct encode_state *encode_state,
2289 struct intel_encoder_context *encoder_context)
2291 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2292 struct intel_batchbuffer *batch;
2293 VAEncSliceParameterBufferMPEG2 *next_slice_group_param = NULL;
2297 batch = mfc_context->aux_batchbuffer;
2298 batch_bo = batch->buffer;
2300 for (i = 0; i < encode_state->num_slice_params_ext; i++) {
2301 if (i == encode_state->num_slice_params_ext - 1)
2302 next_slice_group_param = NULL;
2304 next_slice_group_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[i + 1]->buffer;
2306 gen75_mfc_mpeg2_pipeline_slice_group(ctx, encode_state, encoder_context, i, next_slice_group_param, batch);
2309 intel_batchbuffer_align(batch, 8);
2311 BEGIN_BCS_BATCH(batch, 2);
2312 OUT_BCS_BATCH(batch, 0);
2313 OUT_BCS_BATCH(batch, MI_BATCH_BUFFER_END);
2314 ADVANCE_BCS_BATCH(batch);
2316 dri_bo_reference(batch_bo);
2317 intel_batchbuffer_free(batch);
2318 mfc_context->aux_batchbuffer = NULL;
2324 gen75_mfc_mpeg2_pipeline_picture_programing(VADriverContextP ctx,
2325 struct encode_state *encode_state,
2326 struct intel_encoder_context *encoder_context)
2328 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2330 mfc_context->pipe_mode_select(ctx, MFX_FORMAT_MPEG2, encoder_context);
2331 mfc_context->set_surface_state(ctx, encoder_context);
2332 mfc_context->ind_obj_base_addr_state(ctx, encoder_context);
2333 gen75_mfc_pipe_buf_addr_state(ctx, encoder_context);
2334 gen75_mfc_bsp_buf_base_addr_state(ctx, encoder_context);
2335 gen75_mfc_mpeg2_pic_state(ctx, encoder_context, encode_state);
2336 gen75_mfc_mpeg2_qm_state(ctx, encoder_context);
2337 gen75_mfc_mpeg2_fqm_state(ctx, encoder_context);
2341 gen75_mfc_mpeg2_pipeline_programing(VADriverContextP ctx,
2342 struct encode_state *encode_state,
2343 struct intel_encoder_context *encoder_context)
2345 struct intel_batchbuffer *batch = encoder_context->base.batch;
2346 dri_bo *slice_batch_bo;
2348 slice_batch_bo = gen75_mfc_mpeg2_software_slice_batchbuffer(ctx, encode_state, encoder_context);
2351 intel_batchbuffer_start_atomic_bcs(batch, 0x4000);
2352 intel_batchbuffer_emit_mi_flush(batch);
2354 // picture level programing
2355 gen75_mfc_mpeg2_pipeline_picture_programing(ctx, encode_state, encoder_context);
2357 BEGIN_BCS_BATCH(batch, 2);
2358 OUT_BCS_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8));
2359 OUT_BCS_RELOC(batch,
2361 I915_GEM_DOMAIN_COMMAND, 0,
2363 ADVANCE_BCS_BATCH(batch);
2366 intel_batchbuffer_end_atomic(batch);
2368 dri_bo_unreference(slice_batch_bo);
2372 intel_mfc_mpeg2_prepare(VADriverContextP ctx,
2373 struct encode_state *encode_state,
2374 struct intel_encoder_context *encoder_context)
2376 struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2377 struct object_surface *obj_surface;
2378 struct object_buffer *obj_buffer;
2379 struct i965_coded_buffer_segment *coded_buffer_segment;
2380 VAStatus vaStatus = VA_STATUS_SUCCESS;
2384 /* reconstructed surface */
2385 obj_surface = encode_state->reconstructed_object;
2386 i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
2387 mfc_context->pre_deblocking_output.bo = obj_surface->bo;
2388 dri_bo_reference(mfc_context->pre_deblocking_output.bo);
2389 mfc_context->surface_state.width = obj_surface->orig_width;
2390 mfc_context->surface_state.height = obj_surface->orig_height;
2391 mfc_context->surface_state.w_pitch = obj_surface->width;
2392 mfc_context->surface_state.h_pitch = obj_surface->height;
2394 /* forward reference */
2395 obj_surface = encode_state->reference_objects[0];
2397 if (obj_surface && obj_surface->bo) {
2398 mfc_context->reference_surfaces[0].bo = obj_surface->bo;
2399 dri_bo_reference(mfc_context->reference_surfaces[0].bo);
2401 mfc_context->reference_surfaces[0].bo = NULL;
2403 /* backward reference */
2404 obj_surface = encode_state->reference_objects[1];
2406 if (obj_surface && obj_surface->bo) {
2407 mfc_context->reference_surfaces[1].bo = obj_surface->bo;
2408 dri_bo_reference(mfc_context->reference_surfaces[1].bo);
2410 mfc_context->reference_surfaces[1].bo = mfc_context->reference_surfaces[0].bo;
2412 if (mfc_context->reference_surfaces[1].bo)
2413 dri_bo_reference(mfc_context->reference_surfaces[1].bo);
2416 for (i = 2; i < ARRAY_ELEMS(mfc_context->reference_surfaces); i++) {
2417 mfc_context->reference_surfaces[i].bo = mfc_context->reference_surfaces[i & 1].bo;
2419 if (mfc_context->reference_surfaces[i].bo)
2420 dri_bo_reference(mfc_context->reference_surfaces[i].bo);
2423 /* input YUV surface */
2424 obj_surface = encode_state->input_yuv_object;
2425 mfc_context->uncompressed_picture_source.bo = obj_surface->bo;
2426 dri_bo_reference(mfc_context->uncompressed_picture_source.bo);
2429 obj_buffer = encode_state->coded_buf_object;
2430 bo = obj_buffer->buffer_store->bo;
2431 mfc_context->mfc_indirect_pak_bse_object.bo = bo;
2432 mfc_context->mfc_indirect_pak_bse_object.offset = I965_CODEDBUFFER_HEADER_SIZE;
2433 mfc_context->mfc_indirect_pak_bse_object.end_offset = ALIGN(obj_buffer->size_element - 0x1000, 0x1000);
2434 dri_bo_reference(mfc_context->mfc_indirect_pak_bse_object.bo);
2436 /* set the internal flag to 0 to indicate the coded size is unknown */
2438 coded_buffer_segment = (struct i965_coded_buffer_segment *)bo->virtual;
2439 coded_buffer_segment->mapped = 0;
2440 coded_buffer_segment->codec = encoder_context->codec;
2447 gen75_mfc_mpeg2_encode_picture(VADriverContextP ctx,
2448 struct encode_state *encode_state,
2449 struct intel_encoder_context *encoder_context)
2451 gen75_mfc_init(ctx, encode_state, encoder_context);
2452 intel_mfc_mpeg2_prepare(ctx, encode_state, encoder_context);
2453 /*Programing bcs pipeline*/
2454 gen75_mfc_mpeg2_pipeline_programing(ctx, encode_state, encoder_context);
2455 gen75_mfc_run(ctx, encode_state, encoder_context);
2457 return VA_STATUS_SUCCESS;
2461 gen75_mfc_context_destroy(void *context)
2463 struct gen6_mfc_context *mfc_context = context;
2466 dri_bo_unreference(mfc_context->post_deblocking_output.bo);
2467 mfc_context->post_deblocking_output.bo = NULL;
2469 dri_bo_unreference(mfc_context->pre_deblocking_output.bo);
2470 mfc_context->pre_deblocking_output.bo = NULL;
2472 dri_bo_unreference(mfc_context->uncompressed_picture_source.bo);
2473 mfc_context->uncompressed_picture_source.bo = NULL;
2475 dri_bo_unreference(mfc_context->mfc_indirect_pak_bse_object.bo);
2476 mfc_context->mfc_indirect_pak_bse_object.bo = NULL;
2478 for (i = 0; i < NUM_MFC_DMV_BUFFERS; i++){
2479 dri_bo_unreference(mfc_context->direct_mv_buffers[i].bo);
2480 mfc_context->direct_mv_buffers[i].bo = NULL;
2483 dri_bo_unreference(mfc_context->intra_row_store_scratch_buffer.bo);
2484 mfc_context->intra_row_store_scratch_buffer.bo = NULL;
2486 dri_bo_unreference(mfc_context->macroblock_status_buffer.bo);
2487 mfc_context->macroblock_status_buffer.bo = NULL;
2489 dri_bo_unreference(mfc_context->deblocking_filter_row_store_scratch_buffer.bo);
2490 mfc_context->deblocking_filter_row_store_scratch_buffer.bo = NULL;
2492 dri_bo_unreference(mfc_context->bsd_mpc_row_store_scratch_buffer.bo);
2493 mfc_context->bsd_mpc_row_store_scratch_buffer.bo = NULL;
2495 for (i = 0; i < MAX_MFC_REFERENCE_SURFACES; i++){
2496 dri_bo_unreference(mfc_context->reference_surfaces[i].bo);
2497 mfc_context->reference_surfaces[i].bo = NULL;
2500 i965_gpe_context_destroy(&mfc_context->gpe_context);
2502 dri_bo_unreference(mfc_context->mfc_batchbuffer_surface.bo);
2503 mfc_context->mfc_batchbuffer_surface.bo = NULL;
2505 dri_bo_unreference(mfc_context->aux_batchbuffer_surface.bo);
2506 mfc_context->aux_batchbuffer_surface.bo = NULL;
2508 if (mfc_context->aux_batchbuffer)
2509 intel_batchbuffer_free(mfc_context->aux_batchbuffer);
2511 mfc_context->aux_batchbuffer = NULL;
2516 static VAStatus gen75_mfc_pipeline(VADriverContextP ctx,
2518 struct encode_state *encode_state,
2519 struct intel_encoder_context *encoder_context)
2524 case VAProfileH264ConstrainedBaseline:
2525 case VAProfileH264Main:
2526 case VAProfileH264High:
2527 case VAProfileH264MultiviewHigh:
2528 case VAProfileH264StereoHigh:
2529 vaStatus = gen75_mfc_avc_encode_picture(ctx, encode_state, encoder_context);
2532 /* FIXME: add for other profile */
2533 case VAProfileMPEG2Simple:
2534 case VAProfileMPEG2Main:
2535 vaStatus = gen75_mfc_mpeg2_encode_picture(ctx, encode_state, encoder_context);
2539 vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
2546 Bool gen75_mfc_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
2548 struct gen6_mfc_context *mfc_context = calloc(1, sizeof(struct gen6_mfc_context));
2553 mfc_context->gpe_context.surface_state_binding_table.length = (SURFACE_STATE_PADDED_SIZE + sizeof(unsigned int)) * MAX_MEDIA_SURFACES_GEN6;
2555 mfc_context->gpe_context.idrt.max_entries = MAX_GPE_KERNELS;
2556 mfc_context->gpe_context.idrt.entry_size = sizeof(struct gen6_interface_descriptor_data);
2558 mfc_context->gpe_context.curbe.length = 32 * 4;
2560 mfc_context->gpe_context.vfe_state.max_num_threads = 60 - 1;
2561 mfc_context->gpe_context.vfe_state.num_urb_entries = 16;
2562 mfc_context->gpe_context.vfe_state.gpgpu_mode = 0;
2563 mfc_context->gpe_context.vfe_state.urb_entry_size = 59 - 1;
2564 mfc_context->gpe_context.vfe_state.curbe_allocation_size = 37 - 1;
2566 i965_gpe_load_kernels(ctx,
2567 &mfc_context->gpe_context,
2571 mfc_context->pipe_mode_select = gen75_mfc_pipe_mode_select;
2572 mfc_context->set_surface_state = gen75_mfc_surface_state;
2573 mfc_context->ind_obj_base_addr_state = gen75_mfc_ind_obj_base_addr_state;
2574 mfc_context->avc_img_state = gen75_mfc_avc_img_state;
2575 mfc_context->avc_qm_state = gen75_mfc_avc_qm_state;
2576 mfc_context->avc_fqm_state = gen75_mfc_avc_fqm_state;
2577 mfc_context->insert_object = gen75_mfc_avc_insert_object;
2578 mfc_context->buffer_suface_setup = gen7_gpe_buffer_suface_setup;
2580 encoder_context->mfc_context = mfc_context;
2581 encoder_context->mfc_context_destroy = gen75_mfc_context_destroy;
2582 encoder_context->mfc_pipeline = gen75_mfc_pipeline;
2583 encoder_context->mfc_brc_prepare = intel_mfc_brc_prepare;