src/gen8_vme.c

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  *
   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:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  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.
  23  *
  24  * Authors:
  25  *    Zhao Yakui <yakui.zhao@intel.com>
  26  *    Xiang Haihao <haihao.xiang@intel.com>
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <stdbool.h>
  32 #include <string.h>
  33 #include <assert.h>
  34
  35 #include "intel_batchbuffer.h"
  36 #include "intel_driver.h"
  37
  38 #include "i965_defines.h"
  39 #include "i965_drv_video.h"
  40 #include "i965_encoder.h"
  41 #include "gen6_vme.h"
  42 #include "gen6_mfc.h"
  43
  44 #ifdef SURFACE_STATE_PADDED_SIZE
  45 #undef SURFACE_STATE_PADDED_SIZE
  46 #endif
  47
  48 #define SURFACE_STATE_PADDED_SIZE               SURFACE_STATE_PADDED_SIZE_GEN8
  49 #define SURFACE_STATE_OFFSET(index)             (SURFACE_STATE_PADDED_SIZE * index)
  50 #define BINDING_TABLE_OFFSET(index)             (SURFACE_STATE_OFFSET(MAX_MEDIA_SURFACES_GEN6) + sizeof(unsigned int) * index)
  51
  52 #define VME_INTRA_SHADER        0
  53 #define VME_INTER_SHADER        1
  54 #define VME_BINTER_SHADER       2
  55
  56 #define CURBE_ALLOCATION_SIZE   37              /* in 256-bit */
  57 #define CURBE_TOTAL_DATA_LENGTH (4 * 32)        /* in byte, it should be less than or equal to CURBE_ALLOCATION_SIZE * 32 */
  58 #define CURBE_URB_ENTRY_LENGTH  4               /* in 256-bit, it should be less than or equal to CURBE_TOTAL_DATA_LENGTH / 32 */
  59
  60 #define VME_MSG_LENGTH          32
  61
  62 static const uint32_t gen8_vme_intra_frame[][4] = {
  63 #include "shaders/vme/intra_frame_gen8.g8b"
  64 };
  65
  66 static const uint32_t gen8_vme_inter_frame[][4] = {
  67 #include "shaders/vme/inter_frame_gen8.g8b"
  68 };
  69
  70 static const uint32_t gen8_vme_inter_bframe[][4] = {
  71 #include "shaders/vme/inter_bframe_gen8.g8b"
  72 };
  73
  74 static struct i965_kernel gen8_vme_kernels[] = {
  75     {
  76         "VME Intra Frame",
  77         VME_INTRA_SHADER, /*index*/
  78         gen8_vme_intra_frame,
  79         sizeof(gen8_vme_intra_frame),
  80         NULL
  81     },
  82     {
  83         "VME inter Frame",
  84         VME_INTER_SHADER,
  85         gen8_vme_inter_frame,
  86         sizeof(gen8_vme_inter_frame),
  87         NULL
  88     },
  89     {
  90         "VME inter BFrame",
  91         VME_BINTER_SHADER,
  92         gen8_vme_inter_bframe,
  93         sizeof(gen8_vme_inter_bframe),
  94         NULL
  95     }
  96 };
  97
  98 static const uint32_t gen8_vme_mpeg2_intra_frame[][4] = {
  99 #include "shaders/vme/intra_frame_gen8.g8b"
 100 };
 101
 102 static const uint32_t gen8_vme_mpeg2_inter_frame[][4] = {
 103 #include "shaders/vme/mpeg2_inter_gen8.g8b"
 104 };
 105
 106 static struct i965_kernel gen8_vme_mpeg2_kernels[] = {
 107     {
 108         "VME Intra Frame",
 109         VME_INTRA_SHADER, /*index*/
 110         gen8_vme_mpeg2_intra_frame,
 111         sizeof(gen8_vme_mpeg2_intra_frame),
 112         NULL
 113     },
 114     {
 115         "VME inter Frame",
 116         VME_INTER_SHADER,
 117         gen8_vme_mpeg2_inter_frame,
 118         sizeof(gen8_vme_mpeg2_inter_frame),
 119         NULL
 120     },
 121 };
 122
 123 /* only used for VME source surface state */
 124 static void
 125 gen8_vme_source_surface_state(VADriverContextP ctx,
 126                               int index,
 127                               struct object_surface *obj_surface,
 128                               struct intel_encoder_context *encoder_context)
 129 {
 130     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 131
 132     vme_context->vme_surface2_setup(ctx,
 133                                     &vme_context->gpe_context,
 134                                     obj_surface,
 135                                     BINDING_TABLE_OFFSET(index),
 136                                     SURFACE_STATE_OFFSET(index));
 137 }
 138
 139 static void
 140 gen8_vme_media_source_surface_state(VADriverContextP ctx,
 141                                     int index,
 142                                     struct object_surface *obj_surface,
 143                                     struct intel_encoder_context *encoder_context)
 144 {
 145     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 146
 147     vme_context->vme_media_rw_surface_setup(ctx,
 148                                             &vme_context->gpe_context,
 149                                             obj_surface,
 150                                             BINDING_TABLE_OFFSET(index),
 151                                             SURFACE_STATE_OFFSET(index));
 152 }
 153
 154 static void
 155 gen8_vme_media_chroma_source_surface_state(VADriverContextP ctx,
 156                                            int index,
 157                                            struct object_surface *obj_surface,
 158                                            struct intel_encoder_context *encoder_context)
 159 {
 160     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 161
 162     vme_context->vme_media_chroma_surface_setup(ctx,
 163                                                 &vme_context->gpe_context,
 164                                                 obj_surface,
 165                                                 BINDING_TABLE_OFFSET(index),
 166                                                 SURFACE_STATE_OFFSET(index));
 167 }
 168
 169 static void
 170 gen8_vme_output_buffer_setup(VADriverContextP ctx,
 171                              struct encode_state *encode_state,
 172                              int index,
 173                              struct intel_encoder_context *encoder_context)
 174
 175 {
 176     struct i965_driver_data *i965 = i965_driver_data(ctx);
 177     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 178     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 179     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 180     int is_intra = pSliceParameter->slice_type == SLICE_TYPE_I;
 181     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
 182     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
 183
 184     vme_context->vme_output.num_blocks = width_in_mbs * height_in_mbs;
 185     vme_context->vme_output.pitch = 16; /* in bytes, always 16 */
 186
 187     if (is_intra)
 188         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 2;
 189     else
 190         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 24;
 191     /*
 192      * Inter MV . 32-byte Intra search + 16 IME info + 128 IME MV + 32 IME Ref
 193      * + 16 FBR Info + 128 FBR MV + 32 FBR Ref.
 194      * 16 * (2 + 2 * (1 + 8 + 2))= 16 * 24.
 195      */
 196
 197     vme_context->vme_output.bo = dri_bo_alloc(i965->intel.bufmgr,
 198                                               "VME output buffer",
 199                                               vme_context->vme_output.num_blocks * vme_context->vme_output.size_block,
 200                                               0x1000);
 201     assert(vme_context->vme_output.bo);
 202     vme_context->vme_buffer_suface_setup(ctx,
 203                                          &vme_context->gpe_context,
 204                                          &vme_context->vme_output,
 205                                          BINDING_TABLE_OFFSET(index),
 206                                          SURFACE_STATE_OFFSET(index));
 207 }
 208
 209 static void
 210 gen8_vme_output_vme_batchbuffer_setup(VADriverContextP ctx,
 211                                       struct encode_state *encode_state,
 212                                       int index,
 213                                       struct intel_encoder_context *encoder_context)
 214
 215 {
 216     struct i965_driver_data *i965 = i965_driver_data(ctx);
 217     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 218     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 219     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
 220     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
 221
 222     vme_context->vme_batchbuffer.num_blocks = width_in_mbs * height_in_mbs + 1;
 223     vme_context->vme_batchbuffer.size_block = 64; /* 4 OWORDs */
 224     vme_context->vme_batchbuffer.pitch = 16;
 225     vme_context->vme_batchbuffer.bo = dri_bo_alloc(i965->intel.bufmgr,
 226                                                    "VME batchbuffer",
 227                                                    vme_context->vme_batchbuffer.num_blocks * vme_context->vme_batchbuffer.size_block,
 228                                                    0x1000);
 229         /*
 230     vme_context->vme_buffer_suface_setup(ctx,
 231                                          &vme_context->gpe_context,
 232                                          &vme_context->vme_batchbuffer,
 233                                          BINDING_TABLE_OFFSET(index),
 234                                          SURFACE_STATE_OFFSET(index));
 235         */
 236 }
 237
 238 static VAStatus
 239 gen8_vme_surface_setup(VADriverContextP ctx,
 240                        struct encode_state *encode_state,
 241                        int is_intra,
 242                        struct intel_encoder_context *encoder_context)
 243 {
 244     struct object_surface *obj_surface;
 245
 246     /*Setup surfaces state*/
 247     /* current picture for encoding */
 248     obj_surface = encode_state->input_yuv_object;
 249     gen8_vme_source_surface_state(ctx, 0, obj_surface, encoder_context);
 250     gen8_vme_media_source_surface_state(ctx, 4, obj_surface, encoder_context);
 251     gen8_vme_media_chroma_source_surface_state(ctx, 6, obj_surface, encoder_context);
 252
 253     if (!is_intra) {
 254         VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 255         int slice_type;
 256
 257         slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
 258         assert(slice_type != SLICE_TYPE_I && slice_type != SLICE_TYPE_SI);
 259
 260         intel_avc_vme_reference_state(ctx, encode_state, encoder_context, 0, 1, gen8_vme_source_surface_state);
 261
 262         if (slice_type == SLICE_TYPE_B)
 263             intel_avc_vme_reference_state(ctx, encode_state, encoder_context, 1, 2, gen8_vme_source_surface_state);
 264     }
 265
 266     /* VME output */
 267     gen8_vme_output_buffer_setup(ctx, encode_state, 3, encoder_context);
 268     gen8_vme_output_vme_batchbuffer_setup(ctx, encode_state, 5, encoder_context);
 269
 270     return VA_STATUS_SUCCESS;
 271 }
 272
 273 static VAStatus gen8_vme_interface_setup(VADriverContextP ctx,
 274                                          struct encode_state *encode_state,
 275                                          struct intel_encoder_context *encoder_context)
 276 {
 277     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 278     struct gen8_interface_descriptor_data *desc;
 279     int i;
 280     dri_bo *bo;
 281
 282     bo = vme_context->gpe_context.idrt.bo;
 283     dri_bo_map(bo, 1);
 284     assert(bo->virtual);
 285     desc = bo->virtual;
 286
 287     for (i = 0; i < vme_context->vme_kernel_sum; i++) {
 288         struct i965_kernel *kernel;
 289         kernel = &vme_context->gpe_context.kernels[i];
 290         assert(sizeof(*desc) == 32);
 291         /*Setup the descritor table*/
 292         memset(desc, 0, sizeof(*desc));
 293         desc->desc0.kernel_start_pointer = (kernel->bo->offset >> 6);
 294         desc->desc3.sampler_count = 0; /* FIXME: */
 295         desc->desc3.sampler_state_pointer = 0;
 296         desc->desc4.binding_table_entry_count = 1; /* FIXME: */
 297         desc->desc4.binding_table_pointer = (BINDING_TABLE_OFFSET(0) >> 5);
 298         desc->desc5.constant_urb_entry_read_offset = 0;
 299         desc->desc5.constant_urb_entry_read_length = CURBE_URB_ENTRY_LENGTH;
 300
 301
 302         /*kernel start*/
 303         dri_bo_emit_reloc(bo,
 304                           I915_GEM_DOMAIN_INSTRUCTION, 0,
 305                           0,
 306                           i * sizeof(*desc) + offsetof(struct gen8_interface_descriptor_data, desc0),
 307                           kernel->bo);
 308         desc++;
 309     }
 310     dri_bo_unmap(bo);
 311
 312     return VA_STATUS_SUCCESS;
 313 }
 314
 315 static VAStatus gen8_vme_constant_setup(VADriverContextP ctx,
 316                                         struct encode_state *encode_state,
 317                                         struct intel_encoder_context *encoder_context)
 318 {
 319     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 320     unsigned char *constant_buffer;
 321     unsigned int *vme_state_message;
 322     int mv_num = 32;
 323
 324     vme_state_message = (unsigned int *)vme_context->vme_state_message;
 325
 326     if (encoder_context->codec == CODEC_H264) {
 327         if (vme_context->h264_level >= 30) {
 328             mv_num = 16;
 329
 330             if (vme_context->h264_level >= 31)
 331                 mv_num = 8;
 332         }
 333     } else if (encoder_context->codec == CODEC_MPEG2) {
 334         mv_num = 2;
 335     }
 336
 337     vme_state_message[31] = mv_num;
 338
 339     dri_bo_map(vme_context->gpe_context.curbe.bo, 1);
 340     assert(vme_context->gpe_context.curbe.bo->virtual);
 341     constant_buffer = vme_context->gpe_context.curbe.bo->virtual;
 342
 343     /* VME MV/Mb cost table is passed by using const buffer */
 344     /* Now it uses the fixed search path. So it is constructed directly
 345      * in the GPU shader.
 346      */
 347     memcpy(constant_buffer, (char *)vme_context->vme_state_message, 128);
 348
 349     dri_bo_unmap(vme_context->gpe_context.curbe.bo);
 350
 351     return VA_STATUS_SUCCESS;
 352 }
 353
 354 #define         MB_SCOREBOARD_A         (1 << 0)
 355 #define         MB_SCOREBOARD_B         (1 << 1)
 356 #define         MB_SCOREBOARD_C         (1 << 2)
 357
 358 /* check whether the mb of (x_index, y_index) is out of bound */
 359 static inline int loop_in_bounds(int x_index, int y_index, int first_mb, int num_mb, int mb_width, int mb_height)
 360 {
 361     int mb_index;
 362     if (x_index < 0 || x_index >= mb_width)
 363         return -1;
 364     if (y_index < 0 || y_index >= mb_height)
 365         return -1;
 366
 367     mb_index = y_index * mb_width + x_index;
 368     if (mb_index < first_mb || mb_index > (first_mb + num_mb))
 369         return -1;
 370     return 0;
 371 }
 372
 373 static void
 374 gen8wa_vme_walker_fill_vme_batchbuffer(VADriverContextP ctx,
 375                                      struct encode_state *encode_state,
 376                                      int mb_width, int mb_height,
 377                                      int kernel,
 378                                      int transform_8x8_mode_flag,
 379                                      struct intel_encoder_context *encoder_context)
 380 {
 381     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 382     int mb_row;
 383     int s;
 384     unsigned int *command_ptr;
 385
 386 #define         USE_SCOREBOARD          (1 << 21)
 387
 388     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 389     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 390
 391     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 392         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 393         int first_mb = pSliceParameter->macroblock_address;
 394         int num_mb = pSliceParameter->num_macroblocks;
 395         unsigned int mb_intra_ub, score_dep;
 396         int x_outer, y_outer, x_inner, y_inner;
 397         int xtemp_outer = 0;
 398
 399         x_outer = first_mb % mb_width;
 400         y_outer = first_mb / mb_width;
 401         mb_row = y_outer;
 402
 403         for (; x_outer < (mb_width -2 ) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 404             x_inner = x_outer;
 405             y_inner = y_outer;
 406             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 407                 mb_intra_ub = 0;
 408                 score_dep = 0;
 409                 if (x_inner != 0) {
 410                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 411                     score_dep |= MB_SCOREBOARD_A;
 412                 }
 413                 if (y_inner != mb_row) {
 414                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 415                     score_dep |= MB_SCOREBOARD_B;
 416                     if (x_inner != 0)
 417                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 418                     if (x_inner != (mb_width -1)) {
 419                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 420                         score_dep |= MB_SCOREBOARD_C;
 421                     }
 422                 }
 423
 424                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 425                 *command_ptr++ = kernel;
 426                 *command_ptr++ = USE_SCOREBOARD;
 427                 /* Indirect data */
 428                 *command_ptr++ = 0;
 429                 /* the (X, Y) term of scoreboard */
 430                 *command_ptr++ = ((y_inner << 16) | x_inner);
 431                 *command_ptr++ = score_dep;
 432                 /*inline data */
 433                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 434                 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 435                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 436                 *command_ptr++ = 0;
 437
 438                 x_inner -= 2;
 439                 y_inner += 1;
 440             }
 441             x_outer += 1;
 442         }
 443
 444         xtemp_outer = mb_width - 2;
 445         if (xtemp_outer < 0)
 446             xtemp_outer = 0;
 447         x_outer = xtemp_outer;
 448         y_outer = first_mb / mb_width;
 449         for (;!loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 450             y_inner = y_outer;
 451             x_inner = x_outer;
 452             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 453                 mb_intra_ub = 0;
 454                 score_dep = 0;
 455                 if (x_inner != 0) {
 456                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 457                     score_dep |= MB_SCOREBOARD_A;
 458                 }
 459                 if (y_inner != mb_row) {
 460                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 461                     score_dep |= MB_SCOREBOARD_B;
 462                     if (x_inner != 0)
 463                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 464
 465                     if (x_inner != (mb_width -1)) {
 466                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 467                         score_dep |= MB_SCOREBOARD_C;
 468                     }
 469                 }
 470
 471                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 472                 *command_ptr++ = kernel;
 473                 *command_ptr++ = USE_SCOREBOARD;
 474                 /* Indirect data */
 475                 *command_ptr++ = 0;
 476                 /* the (X, Y) term of scoreboard */
 477                 *command_ptr++ = ((y_inner << 16) | x_inner);
 478                 *command_ptr++ = score_dep;
 479                 /*inline data */
 480                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 481                 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 482
 483                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 484                 *command_ptr++ = 0;
 485                 x_inner -= 2;
 486                 y_inner += 1;
 487             }
 488             x_outer++;
 489             if (x_outer >= mb_width) {
 490                 y_outer += 1;
 491                 x_outer = xtemp_outer;
 492             }
 493         }
 494     }
 495
 496     *command_ptr++ = MI_BATCH_BUFFER_END;
 497     *command_ptr++ = 0;
 498
 499     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 500 }
 501
 502 static void
 503 gen8_vme_fill_vme_batchbuffer(VADriverContextP ctx,
 504                               struct encode_state *encode_state,
 505                               int mb_width, int mb_height,
 506                               int kernel,
 507                               int transform_8x8_mode_flag,
 508                               struct intel_encoder_context *encoder_context)
 509 {
 510     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 511     int mb_x = 0, mb_y = 0;
 512     int i, s;
 513     unsigned int *command_ptr;
 514
 515     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 516     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 517
 518     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 519         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 520         int slice_mb_begin = pSliceParameter->macroblock_address;
 521         int slice_mb_number = pSliceParameter->num_macroblocks;
 522         unsigned int mb_intra_ub;
 523         int slice_mb_x = pSliceParameter->macroblock_address % mb_width;
 524         for (i = 0; i < slice_mb_number;  ) {
 525             int mb_count = i + slice_mb_begin;
 526             mb_x = mb_count % mb_width;
 527             mb_y = mb_count / mb_width;
 528             mb_intra_ub = 0;
 529             if (mb_x != 0) {
 530                 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 531             }
 532             if (mb_y != 0) {
 533                 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 534                 if (mb_x != 0)
 535                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 536                 if (mb_x != (mb_width -1))
 537                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 538             }
 539             if (i < mb_width) {
 540                 if (i == 0)
 541                     mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_AE);
 542                 mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_BCD_MASK);
 543                 if ((i == (mb_width - 1)) && slice_mb_x) {
 544                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 545                 }
 546             }
 547
 548             if ((i == mb_width) && slice_mb_x) {
 549                 mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_D);
 550             }
 551             *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 552             *command_ptr++ = kernel;
 553             *command_ptr++ = 0;
 554             *command_ptr++ = 0;
 555             *command_ptr++ = 0;
 556             *command_ptr++ = 0;
 557
 558             /*inline data */
 559             *command_ptr++ = (mb_width << 16 | mb_y << 8 | mb_x);
 560             *command_ptr++ = ( (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 561
 562             *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 563             *command_ptr++ = 0;
 564             i += 1;
 565         }
 566     }
 567
 568     *command_ptr++ = MI_BATCH_BUFFER_END;
 569     *command_ptr++ = 0;
 570
 571     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 572 }
 573
 574 static void gen8_vme_media_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
 575 {
 576     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 577
 578     i965_gpe_context_init(ctx, &vme_context->gpe_context);
 579
 580     /* VME output buffer */
 581     dri_bo_unreference(vme_context->vme_output.bo);
 582     vme_context->vme_output.bo = NULL;
 583
 584     dri_bo_unreference(vme_context->vme_batchbuffer.bo);
 585     vme_context->vme_batchbuffer.bo = NULL;
 586
 587     /* VME state */
 588     dri_bo_unreference(vme_context->vme_state.bo);
 589     vme_context->vme_state.bo = NULL;
 590 }
 591
 592 static void gen8_vme_pipeline_programing(VADriverContextP ctx,
 593                                          struct encode_state *encode_state,
 594                                          struct intel_encoder_context *encoder_context)
 595 {
 596     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 597     struct intel_batchbuffer *batch = encoder_context->base.batch;
 598     VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
 599     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 600     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 601     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
 602     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
 603     int kernel_shader;
 604     bool allow_hwscore = true;
 605     int s;
 606
 607     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 608         pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 609         if ((pSliceParameter->macroblock_address % width_in_mbs)) {
 610             allow_hwscore = false;
 611             break;
 612         }
 613     }
 614
 615     if ((pSliceParameter->slice_type == SLICE_TYPE_I) ||
 616         (pSliceParameter->slice_type == SLICE_TYPE_I)) {
 617         kernel_shader = VME_INTRA_SHADER;
 618     } else if ((pSliceParameter->slice_type == SLICE_TYPE_P) ||
 619                (pSliceParameter->slice_type == SLICE_TYPE_SP)) {
 620         kernel_shader = VME_INTER_SHADER;
 621     } else {
 622         kernel_shader = VME_BINTER_SHADER;
 623         if (!allow_hwscore)
 624             kernel_shader = VME_INTER_SHADER;
 625     }
 626     if (allow_hwscore)
 627         gen8wa_vme_walker_fill_vme_batchbuffer(ctx,
 628                                              encode_state,
 629                                              width_in_mbs, height_in_mbs,
 630                                              kernel_shader,
 631                                              pPicParameter->pic_fields.bits.transform_8x8_mode_flag,
 632                                              encoder_context);
 633     else
 634         gen8_vme_fill_vme_batchbuffer(ctx,
 635                                       encode_state,
 636                                       width_in_mbs, height_in_mbs,
 637                                       kernel_shader,
 638                                       pPicParameter->pic_fields.bits.transform_8x8_mode_flag,
 639                                       encoder_context);
 640
 641     intel_batchbuffer_start_atomic(batch, 0x1000);
 642     gen8_gpe_pipeline_setup(ctx, &vme_context->gpe_context, batch);
 643     BEGIN_BATCH(batch, 3);
 644     OUT_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8) | (1 << 0));
 645     OUT_RELOC(batch,
 646               vme_context->vme_batchbuffer.bo,
 647               I915_GEM_DOMAIN_COMMAND, 0,
 648               0);
 649     OUT_BATCH(batch, 0);
 650     ADVANCE_BATCH(batch);
 651
 652     intel_batchbuffer_end_atomic(batch);
 653 }
 654
 655 static VAStatus gen8_vme_prepare(VADriverContextP ctx,
 656                                  struct encode_state *encode_state,
 657                                  struct intel_encoder_context *encoder_context)
 658 {
 659     VAStatus vaStatus = VA_STATUS_SUCCESS;
 660     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 661     int is_intra = pSliceParameter->slice_type == SLICE_TYPE_I;
 662     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 663     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 664
 665     if (!vme_context->h264_level ||
 666         (vme_context->h264_level != pSequenceParameter->level_idc)) {
 667         vme_context->h264_level = pSequenceParameter->level_idc;
 668     }
 669
 670     intel_vme_update_mbmv_cost(ctx, encode_state, encoder_context);
 671
 672     /*Setup all the memory object*/
 673     gen8_vme_surface_setup(ctx, encode_state, is_intra, encoder_context);
 674     gen8_vme_interface_setup(ctx, encode_state, encoder_context);
 675     //gen8_vme_vme_state_setup(ctx, encode_state, is_intra, encoder_context);
 676     gen8_vme_constant_setup(ctx, encode_state, encoder_context);
 677
 678     /*Programing media pipeline*/
 679     gen8_vme_pipeline_programing(ctx, encode_state, encoder_context);
 680
 681     return vaStatus;
 682 }
 683
 684 static VAStatus gen8_vme_run(VADriverContextP ctx,
 685                              struct encode_state *encode_state,
 686                              struct intel_encoder_context *encoder_context)
 687 {
 688     struct intel_batchbuffer *batch = encoder_context->base.batch;
 689
 690     intel_batchbuffer_flush(batch);
 691
 692     return VA_STATUS_SUCCESS;
 693 }
 694
 695 static VAStatus gen8_vme_stop(VADriverContextP ctx,
 696                               struct encode_state *encode_state,
 697                               struct intel_encoder_context *encoder_context)
 698 {
 699     return VA_STATUS_SUCCESS;
 700 }
 701
 702 static VAStatus
 703 gen8_vme_pipeline(VADriverContextP ctx,
 704                   VAProfile profile,
 705                   struct encode_state *encode_state,
 706                   struct intel_encoder_context *encoder_context)
 707 {
 708     gen8_vme_media_init(ctx, encoder_context);
 709     gen8_vme_prepare(ctx, encode_state, encoder_context);
 710     gen8_vme_run(ctx, encode_state, encoder_context);
 711     gen8_vme_stop(ctx, encode_state, encoder_context);
 712
 713     return VA_STATUS_SUCCESS;
 714 }
 715
 716 static void
 717 gen8_vme_mpeg2_output_buffer_setup(VADriverContextP ctx,
 718                                    struct encode_state *encode_state,
 719                                    int index,
 720                                    int is_intra,
 721                                    struct intel_encoder_context *encoder_context)
 722
 723 {
 724     struct i965_driver_data *i965 = i965_driver_data(ctx);
 725     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 726     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 727     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 728     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 729
 730     vme_context->vme_output.num_blocks = width_in_mbs * height_in_mbs;
 731     vme_context->vme_output.pitch = 16; /* in bytes, always 16 */
 732
 733     if (is_intra)
 734         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 2;
 735     else
 736         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 24;
 737     /*
 738      * Inter MV . 32-byte Intra search + 16 IME info + 128 IME MV + 32 IME Ref
 739      * + 16 FBR Info + 128 FBR MV + 32 FBR Ref.
 740      * 16 * (2 + 2 * (1 + 8 + 2))= 16 * 24.
 741      */
 742
 743     vme_context->vme_output.bo = dri_bo_alloc(i965->intel.bufmgr,
 744                                               "VME output buffer",
 745                                               vme_context->vme_output.num_blocks * vme_context->vme_output.size_block,
 746                                               0x1000);
 747     assert(vme_context->vme_output.bo);
 748     vme_context->vme_buffer_suface_setup(ctx,
 749                                          &vme_context->gpe_context,
 750                                          &vme_context->vme_output,
 751                                          BINDING_TABLE_OFFSET(index),
 752                                          SURFACE_STATE_OFFSET(index));
 753 }
 754
 755 static void
 756 gen8_vme_mpeg2_output_vme_batchbuffer_setup(VADriverContextP ctx,
 757                                             struct encode_state *encode_state,
 758                                             int index,
 759                                             struct intel_encoder_context *encoder_context)
 760
 761 {
 762     struct i965_driver_data *i965 = i965_driver_data(ctx);
 763     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 764     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 765     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 766     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 767
 768     vme_context->vme_batchbuffer.num_blocks = width_in_mbs * height_in_mbs + 1;
 769     vme_context->vme_batchbuffer.size_block = 64; /* 4 OWORDs */
 770     vme_context->vme_batchbuffer.pitch = 16;
 771     vme_context->vme_batchbuffer.bo = dri_bo_alloc(i965->intel.bufmgr,
 772                                                    "VME batchbuffer",
 773                                                    vme_context->vme_batchbuffer.num_blocks * vme_context->vme_batchbuffer.size_block,
 774                                                    0x1000);
 775     vme_context->vme_buffer_suface_setup(ctx,
 776                                          &vme_context->gpe_context,
 777                                          &vme_context->vme_batchbuffer,
 778                                          BINDING_TABLE_OFFSET(index),
 779                                          SURFACE_STATE_OFFSET(index));
 780 }
 781
 782 static VAStatus
 783 gen8_vme_mpeg2_surface_setup(VADriverContextP ctx,
 784                              struct encode_state *encode_state,
 785                              int is_intra,
 786                              struct intel_encoder_context *encoder_context)
 787 {
 788     struct object_surface *obj_surface;
 789
 790     /*Setup surfaces state*/
 791     /* current picture for encoding */
 792     obj_surface = encode_state->input_yuv_object;
 793     gen8_vme_source_surface_state(ctx, 0, obj_surface, encoder_context);
 794     gen8_vme_media_source_surface_state(ctx, 4, obj_surface, encoder_context);
 795     gen8_vme_media_chroma_source_surface_state(ctx, 6, obj_surface, encoder_context);
 796
 797     if (!is_intra) {
 798         /* reference 0 */
 799         obj_surface = encode_state->reference_objects[0];
 800
 801         if (obj_surface->bo != NULL)
 802             gen8_vme_source_surface_state(ctx, 1, obj_surface, encoder_context);
 803
 804         /* reference 1 */
 805         obj_surface = encode_state->reference_objects[1];
 806
 807         if (obj_surface && obj_surface->bo != NULL)
 808             gen8_vme_source_surface_state(ctx, 2, obj_surface, encoder_context);
 809     }
 810
 811     /* VME output */
 812     gen8_vme_mpeg2_output_buffer_setup(ctx, encode_state, 3, is_intra, encoder_context);
 813     gen8_vme_mpeg2_output_vme_batchbuffer_setup(ctx, encode_state, 5, encoder_context);
 814
 815     return VA_STATUS_SUCCESS;
 816 }
 817
 818 static void
 819 gen8wa_vme_mpeg2_walker_fill_vme_batchbuffer(VADriverContextP ctx,
 820                                            struct encode_state *encode_state,
 821                                            int mb_width, int mb_height,
 822                                            int kernel,
 823                                            struct intel_encoder_context *encoder_context)
 824 {
 825     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 826     unsigned int *command_ptr;
 827
 828 #define         MPEG2_SCOREBOARD                (1 << 21)
 829
 830     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 831     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 832
 833     {
 834         unsigned int mb_intra_ub, score_dep;
 835         int x_outer, y_outer, x_inner, y_inner;
 836         int xtemp_outer = 0;
 837         int first_mb = 0;
 838         int num_mb = mb_width * mb_height;
 839
 840         x_outer = 0;
 841         y_outer = 0;
 842
 843
 844         for (; x_outer < (mb_width -2 ) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 845             x_inner = x_outer;
 846             y_inner = y_outer;
 847             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 848                 mb_intra_ub = 0;
 849                 score_dep = 0;
 850                 if (x_inner != 0) {
 851                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 852                     score_dep |= MB_SCOREBOARD_A;
 853                 }
 854                 if (y_inner != 0) {
 855                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 856                     score_dep |= MB_SCOREBOARD_B;
 857
 858                     if (x_inner != 0)
 859                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 860
 861                     if (x_inner != (mb_width -1)) {
 862                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 863                         score_dep |= MB_SCOREBOARD_C;
 864                     }
 865                 }
 866
 867                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 868                 *command_ptr++ = kernel;
 869                 *command_ptr++ = MPEG2_SCOREBOARD;
 870                 /* Indirect data */
 871                 *command_ptr++ = 0;
 872                 /* the (X, Y) term of scoreboard */
 873                 *command_ptr++ = ((y_inner << 16) | x_inner);
 874                 *command_ptr++ = score_dep;
 875                 /*inline data */
 876                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 877                 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
 878                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 879                 *command_ptr++ = 0;
 880
 881                 x_inner -= 2;
 882                 y_inner += 1;
 883             }
 884             x_outer += 1;
 885         }
 886
 887         xtemp_outer = mb_width - 2;
 888         if (xtemp_outer < 0)
 889             xtemp_outer = 0;
 890         x_outer = xtemp_outer;
 891         y_outer = 0;
 892         for (;!loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 893             y_inner = y_outer;
 894             x_inner = x_outer;
 895             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 896                 mb_intra_ub = 0;
 897                 score_dep = 0;
 898                 if (x_inner != 0) {
 899                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 900                     score_dep |= MB_SCOREBOARD_A;
 901                 }
 902                 if (y_inner != 0) {
 903                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 904                     score_dep |= MB_SCOREBOARD_B;
 905
 906                     if (x_inner != 0)
 907                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 908
 909                     if (x_inner != (mb_width -1)) {
 910                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 911                         score_dep |= MB_SCOREBOARD_C;
 912                     }
 913                 }
 914
 915                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 916                 *command_ptr++ = kernel;
 917                 *command_ptr++ = MPEG2_SCOREBOARD;
 918                 /* Indirect data */
 919                 *command_ptr++ = 0;
 920                 /* the (X, Y) term of scoreboard */
 921                 *command_ptr++ = ((y_inner << 16) | x_inner);
 922                 *command_ptr++ = score_dep;
 923                 /*inline data */
 924                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 925                 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
 926
 927                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 928                 *command_ptr++ = 0;
 929                 x_inner -= 2;
 930                 y_inner += 1;
 931             }
 932             x_outer++;
 933             if (x_outer >= mb_width) {
 934                 y_outer += 1;
 935                 x_outer = xtemp_outer;
 936             }
 937         }
 938     }
 939
 940     *command_ptr++ = MI_BATCH_BUFFER_END;
 941     *command_ptr++ = 0;
 942
 943     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 944     return;
 945 }
 946
 947 static void
 948 gen8_vme_mpeg2_fill_vme_batchbuffer(VADriverContextP ctx,
 949                                     struct encode_state *encode_state,
 950                                     int mb_width, int mb_height,
 951                                     int kernel,
 952                                     int transform_8x8_mode_flag,
 953                                     struct intel_encoder_context *encoder_context)
 954 {
 955     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 956     int mb_x = 0, mb_y = 0;
 957     int i, s, j;
 958     unsigned int *command_ptr;
 959
 960
 961     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 962     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 963
 964     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 965         VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[s]->buffer;
 966
 967         for (j = 0; j < encode_state->slice_params_ext[s]->num_elements; j++) {
 968             int slice_mb_begin = slice_param->macroblock_address;
 969             int slice_mb_number = slice_param->num_macroblocks;
 970             unsigned int mb_intra_ub;
 971
 972             for (i = 0; i < slice_mb_number;) {
 973                 int mb_count = i + slice_mb_begin;
 974
 975                 mb_x = mb_count % mb_width;
 976                 mb_y = mb_count / mb_width;
 977                 mb_intra_ub = 0;
 978
 979                 if (mb_x != 0) {
 980                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 981                 }
 982
 983                 if (mb_y != 0) {
 984                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 985
 986                     if (mb_x != 0)
 987                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 988
 989                     if (mb_x != (mb_width -1))
 990                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 991                 }
 992
 993                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 994                 *command_ptr++ = kernel;
 995                 *command_ptr++ = 0;
 996                 *command_ptr++ = 0;
 997                 *command_ptr++ = 0;
 998                 *command_ptr++ = 0;
 999
1000                 /*inline data */
1001                 *command_ptr++ = (mb_width << 16 | mb_y << 8 | mb_x);
1002                 *command_ptr++ = ( (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
1003
1004                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
1005                 *command_ptr++ = 0;
1006                 i += 1;
1007             }
1008
1009             slice_param++;
1010         }
1011     }
1012
1013     *command_ptr++ = MI_BATCH_BUFFER_END;
1014     *command_ptr++ = 0;
1015
1016     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
1017 }
1018
1019 static void
1020 gen8_vme_mpeg2_pipeline_programing(VADriverContextP ctx,
1021                                    struct encode_state *encode_state,
1022                                    int is_intra,
1023                                    struct intel_encoder_context *encoder_context)
1024 {
1025     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1026     struct intel_batchbuffer *batch = encoder_context->base.batch;
1027     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
1028     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
1029     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
1030     bool allow_hwscore = true;
1031     int s;
1032     int kernel_shader;
1033     VAEncPictureParameterBufferMPEG2 *pic_param = NULL;
1034
1035     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
1036         int j;
1037         VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[s]->buffer;
1038
1039         for (j = 0; j < encode_state->slice_params_ext[s]->num_elements; j++) {
1040             if (slice_param->macroblock_address % width_in_mbs) {
1041                 allow_hwscore = false;
1042                 break;
1043             }
1044         }
1045     }
1046
1047     pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
1048     if (pic_param->picture_type == VAEncPictureTypeIntra) {
1049         allow_hwscore = false;
1050         kernel_shader = VME_INTRA_SHADER;
1051     } else {
1052         kernel_shader = VME_INTER_SHADER;
1053     }
1054
1055     if (allow_hwscore)
1056         gen8wa_vme_mpeg2_walker_fill_vme_batchbuffer(ctx,
1057                                                    encode_state,
1058                                                    width_in_mbs, height_in_mbs,
1059                                                    kernel_shader,
1060                                                    encoder_context);
1061     else
1062         gen8_vme_mpeg2_fill_vme_batchbuffer(ctx,
1063                                             encode_state,
1064                                             width_in_mbs, height_in_mbs,
1065                                             is_intra ? VME_INTRA_SHADER : VME_INTER_SHADER,
1066                                             0,
1067                                             encoder_context);
1068
1069     intel_batchbuffer_start_atomic(batch, 0x1000);
1070     gen8_gpe_pipeline_setup(ctx, &vme_context->gpe_context, batch);
1071     BEGIN_BATCH(batch, 4);
1072     OUT_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8) | (1 << 0));
1073     OUT_RELOC(batch,
1074               vme_context->vme_batchbuffer.bo,
1075               I915_GEM_DOMAIN_COMMAND, 0,
1076               0);
1077     OUT_BATCH(batch, 0);
1078     OUT_BATCH(batch, 0);
1079     ADVANCE_BATCH(batch);
1080
1081     intel_batchbuffer_end_atomic(batch);
1082 }
1083
1084 static VAStatus
1085 gen8_vme_mpeg2_prepare(VADriverContextP ctx,
1086                        struct encode_state *encode_state,
1087                        struct intel_encoder_context *encoder_context)
1088 {
1089     VAStatus vaStatus = VA_STATUS_SUCCESS;
1090     VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[0]->buffer;
1091     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
1092     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1093
1094     if ((!vme_context->mpeg2_level) ||
1095         (vme_context->mpeg2_level != (seq_param->sequence_extension.bits.profile_and_level_indication & MPEG2_LEVEL_MASK))) {
1096         vme_context->mpeg2_level = seq_param->sequence_extension.bits.profile_and_level_indication & MPEG2_LEVEL_MASK;
1097     }
1098
1099
1100     /*Setup all the memory object*/
1101     gen8_vme_mpeg2_surface_setup(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
1102     gen8_vme_interface_setup(ctx, encode_state, encoder_context);
1103     //gen8_vme_vme_state_setup(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
1104     intel_vme_mpeg2_state_setup(ctx, encode_state, encoder_context);
1105     gen8_vme_constant_setup(ctx, encode_state, encoder_context);
1106
1107     /*Programing media pipeline*/
1108     gen8_vme_mpeg2_pipeline_programing(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
1109
1110     return vaStatus;
1111 }
1112
1113 static VAStatus
1114 gen8_vme_mpeg2_pipeline(VADriverContextP ctx,
1115                         VAProfile profile,
1116                         struct encode_state *encode_state,
1117                         struct intel_encoder_context *encoder_context)
1118 {
1119     gen8_vme_media_init(ctx, encoder_context);
1120     gen8_vme_mpeg2_prepare(ctx, encode_state, encoder_context);
1121     gen8_vme_run(ctx, encode_state, encoder_context);
1122     gen8_vme_stop(ctx, encode_state, encoder_context);
1123
1124     return VA_STATUS_SUCCESS;
1125 }
1126
1127 static void
1128 gen8_vme_context_destroy(void *context)
1129 {
1130     struct gen6_vme_context *vme_context = context;
1131
1132     i965_gpe_context_destroy(&vme_context->gpe_context);
1133
1134     dri_bo_unreference(vme_context->vme_output.bo);
1135     vme_context->vme_output.bo = NULL;
1136
1137     dri_bo_unreference(vme_context->vme_state.bo);
1138     vme_context->vme_state.bo = NULL;
1139
1140     dri_bo_unreference(vme_context->vme_batchbuffer.bo);
1141     vme_context->vme_batchbuffer.bo = NULL;
1142
1143     if (vme_context->vme_state_message) {
1144         free(vme_context->vme_state_message);
1145         vme_context->vme_state_message = NULL;
1146     }
1147
1148     free(vme_context);
1149 }
1150
1151 Bool gen8_vme_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
1152 {
1153     struct gen6_vme_context *vme_context = calloc(1, sizeof(struct gen6_vme_context));
1154     struct i965_kernel *vme_kernel_list = NULL;
1155     int i965_kernel_num;
1156
1157     switch (encoder_context->codec) {
1158     case CODEC_H264:
1159         vme_kernel_list = gen8_vme_kernels;
1160         encoder_context->vme_pipeline = gen8_vme_pipeline;
1161         i965_kernel_num = sizeof(gen8_vme_kernels) / sizeof(struct i965_kernel);
1162         break;
1163
1164     case CODEC_MPEG2:
1165         vme_kernel_list = gen8_vme_mpeg2_kernels;
1166         encoder_context->vme_pipeline = gen8_vme_mpeg2_pipeline;
1167         i965_kernel_num = sizeof(gen8_vme_mpeg2_kernels) / sizeof(struct i965_kernel);
1168
1169         break;
1170
1171     default:
1172         /* never get here */
1173         assert(0);
1174
1175         break;
1176     }
1177     vme_context->vme_kernel_sum = i965_kernel_num;
1178     vme_context->gpe_context.surface_state_binding_table.length = (SURFACE_STATE_PADDED_SIZE + sizeof(unsigned int)) * MAX_MEDIA_SURFACES_GEN6;
1179
1180     vme_context->gpe_context.idrt.max_entries = MAX_INTERFACE_DESC_GEN6;
1181     vme_context->gpe_context.idrt.entry_size = sizeof(struct gen8_interface_descriptor_data);
1182
1183     vme_context->gpe_context.curbe.length = CURBE_TOTAL_DATA_LENGTH;
1184
1185     vme_context->gpe_context.vfe_state.max_num_threads = 60 - 1;
1186     vme_context->gpe_context.vfe_state.num_urb_entries = 16;
1187     vme_context->gpe_context.vfe_state.gpgpu_mode = 0;
1188     vme_context->gpe_context.vfe_state.urb_entry_size = 59 - 1;
1189     vme_context->gpe_context.vfe_state.curbe_allocation_size = CURBE_ALLOCATION_SIZE - 1;
1190
1191     gen7_vme_scoreboard_init(ctx, vme_context);
1192
1193     i965_gpe_load_kernels(ctx,
1194                           &vme_context->gpe_context,
1195                           vme_kernel_list,
1196                           i965_kernel_num);
1197     vme_context->vme_surface2_setup = gen8_gpe_surface2_setup;
1198     vme_context->vme_media_rw_surface_setup = gen8_gpe_media_rw_surface_setup;
1199     vme_context->vme_buffer_suface_setup = gen8_gpe_buffer_suface_setup;
1200     vme_context->vme_media_chroma_surface_setup = gen8_gpe_media_chroma_surface_setup;
1201
1202     encoder_context->vme_context = vme_context;
1203     encoder_context->vme_context_destroy = gen8_vme_context_destroy;
1204
1205     vme_context->vme_state_message = malloc(VME_MSG_LENGTH * sizeof(int));
1206
1207     return True;
1208 }