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     unsigned char *desc_ptr;
 282
 283     bo = vme_context->gpe_context.dynamic_state.bo;
 284     dri_bo_map(bo, 1);
 285     assert(bo->virtual);
 286     desc_ptr = (unsigned char *)bo->virtual + vme_context->gpe_context.idrt_offset;
 287
 288     desc = (struct gen8_interface_descriptor_data *)desc_ptr;
 289
 290     for (i = 0; i < vme_context->vme_kernel_sum; i++) {
 291         struct i965_kernel *kernel;
 292         kernel = &vme_context->gpe_context.kernels[i];
 293         assert(sizeof(*desc) == 32);
 294         /*Setup the descritor table*/
 295         memset(desc, 0, sizeof(*desc));
 296         desc->desc0.kernel_start_pointer = kernel->kernel_offset >> 6;
 297         desc->desc3.sampler_count = 0; /* FIXME: */
 298         desc->desc3.sampler_state_pointer = 0;
 299         desc->desc4.binding_table_entry_count = 1; /* FIXME: */
 300         desc->desc4.binding_table_pointer = (BINDING_TABLE_OFFSET(0) >> 5);
 301         desc->desc5.constant_urb_entry_read_offset = 0;
 302         desc->desc5.constant_urb_entry_read_length = CURBE_URB_ENTRY_LENGTH;
 303
 304
 305         desc++;
 306     }
 307
 308     dri_bo_unmap(bo);
 309
 310     return VA_STATUS_SUCCESS;
 311 }
 312
 313 static VAStatus gen8_vme_constant_setup(VADriverContextP ctx,
 314                                         struct encode_state *encode_state,
 315                                         struct intel_encoder_context *encoder_context)
 316 {
 317     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 318     unsigned char *constant_buffer;
 319     unsigned int *vme_state_message;
 320     int mv_num = 32;
 321
 322     vme_state_message = (unsigned int *)vme_context->vme_state_message;
 323
 324     if (encoder_context->codec == CODEC_H264) {
 325         if (vme_context->h264_level >= 30) {
 326             mv_num = 16;
 327
 328             if (vme_context->h264_level >= 31)
 329                 mv_num = 8;
 330         }
 331     } else if (encoder_context->codec == CODEC_MPEG2) {
 332         mv_num = 2;
 333     }
 334
 335     vme_state_message[31] = mv_num;
 336
 337     dri_bo_map(vme_context->gpe_context.dynamic_state.bo, 1);
 338     assert(vme_context->gpe_context.dynamic_state.bo->virtual);
 339     constant_buffer = (unsigned char *)vme_context->gpe_context.dynamic_state.bo->virtual +
 340                                          vme_context->gpe_context.curbe_offset;
 341
 342     /* VME MV/Mb cost table is passed by using const buffer */
 343     /* Now it uses the fixed search path. So it is constructed directly
 344      * in the GPU shader.
 345      */
 346     memcpy(constant_buffer, (char *)vme_context->vme_state_message, 128);
 347
 348     dri_bo_unmap(vme_context->gpe_context.dynamic_state.bo);
 349
 350     return VA_STATUS_SUCCESS;
 351 }
 352
 353 #define         MB_SCOREBOARD_A         (1 << 0)
 354 #define         MB_SCOREBOARD_B         (1 << 1)
 355 #define         MB_SCOREBOARD_C         (1 << 2)
 356
 357 /* check whether the mb of (x_index, y_index) is out of bound */
 358 static inline int loop_in_bounds(int x_index, int y_index, int first_mb, int num_mb, int mb_width, int mb_height)
 359 {
 360     int mb_index;
 361     if (x_index < 0 || x_index >= mb_width)
 362         return -1;
 363     if (y_index < 0 || y_index >= mb_height)
 364         return -1;
 365
 366     mb_index = y_index * mb_width + x_index;
 367     if (mb_index < first_mb || mb_index > (first_mb + num_mb))
 368         return -1;
 369     return 0;
 370 }
 371
 372 static void
 373 gen8wa_vme_walker_fill_vme_batchbuffer(VADriverContextP ctx,
 374                                      struct encode_state *encode_state,
 375                                      int mb_width, int mb_height,
 376                                      int kernel,
 377                                      int transform_8x8_mode_flag,
 378                                      struct intel_encoder_context *encoder_context)
 379 {
 380     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 381     int mb_row;
 382     int s;
 383     unsigned int *command_ptr;
 384
 385 #define         USE_SCOREBOARD          (1 << 21)
 386
 387     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 388     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 389
 390     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 391         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 392         int first_mb = pSliceParameter->macroblock_address;
 393         int num_mb = pSliceParameter->num_macroblocks;
 394         unsigned int mb_intra_ub, score_dep;
 395         int x_outer, y_outer, x_inner, y_inner;
 396         int xtemp_outer = 0;
 397
 398         x_outer = first_mb % mb_width;
 399         y_outer = first_mb / mb_width;
 400         mb_row = y_outer;
 401
 402         for (; x_outer < (mb_width -2 ) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 403             x_inner = x_outer;
 404             y_inner = y_outer;
 405             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 406                 mb_intra_ub = 0;
 407                 score_dep = 0;
 408                 if (x_inner != 0) {
 409                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 410                     score_dep |= MB_SCOREBOARD_A;
 411                 }
 412                 if (y_inner != mb_row) {
 413                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 414                     score_dep |= MB_SCOREBOARD_B;
 415                     if (x_inner != 0)
 416                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 417                     if (x_inner != (mb_width -1)) {
 418                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 419                         score_dep |= MB_SCOREBOARD_C;
 420                     }
 421                 }
 422
 423                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 424                 *command_ptr++ = kernel;
 425                 *command_ptr++ = USE_SCOREBOARD;
 426                 /* Indirect data */
 427                 *command_ptr++ = 0;
 428                 /* the (X, Y) term of scoreboard */
 429                 *command_ptr++ = ((y_inner << 16) | x_inner);
 430                 *command_ptr++ = score_dep;
 431                 /*inline data */
 432                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 433                 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 434                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 435                 *command_ptr++ = 0;
 436
 437                 x_inner -= 2;
 438                 y_inner += 1;
 439             }
 440             x_outer += 1;
 441         }
 442
 443         xtemp_outer = mb_width - 2;
 444         if (xtemp_outer < 0)
 445             xtemp_outer = 0;
 446         x_outer = xtemp_outer;
 447         y_outer = first_mb / mb_width;
 448         for (;!loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 449             y_inner = y_outer;
 450             x_inner = x_outer;
 451             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 452                 mb_intra_ub = 0;
 453                 score_dep = 0;
 454                 if (x_inner != 0) {
 455                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 456                     score_dep |= MB_SCOREBOARD_A;
 457                 }
 458                 if (y_inner != mb_row) {
 459                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 460                     score_dep |= MB_SCOREBOARD_B;
 461                     if (x_inner != 0)
 462                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 463
 464                     if (x_inner != (mb_width -1)) {
 465                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 466                         score_dep |= MB_SCOREBOARD_C;
 467                     }
 468                 }
 469
 470                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 471                 *command_ptr++ = kernel;
 472                 *command_ptr++ = USE_SCOREBOARD;
 473                 /* Indirect data */
 474                 *command_ptr++ = 0;
 475                 /* the (X, Y) term of scoreboard */
 476                 *command_ptr++ = ((y_inner << 16) | x_inner);
 477                 *command_ptr++ = score_dep;
 478                 /*inline data */
 479                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 480                 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 481
 482                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 483                 *command_ptr++ = 0;
 484                 x_inner -= 2;
 485                 y_inner += 1;
 486             }
 487             x_outer++;
 488             if (x_outer >= mb_width) {
 489                 y_outer += 1;
 490                 x_outer = xtemp_outer;
 491             }
 492         }
 493     }
 494
 495     *command_ptr++ = MI_BATCH_BUFFER_END;
 496     *command_ptr++ = 0;
 497
 498     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 499 }
 500
 501 static void
 502 gen8_vme_fill_vme_batchbuffer(VADriverContextP ctx,
 503                               struct encode_state *encode_state,
 504                               int mb_width, int mb_height,
 505                               int kernel,
 506                               int transform_8x8_mode_flag,
 507                               struct intel_encoder_context *encoder_context)
 508 {
 509     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 510     int mb_x = 0, mb_y = 0;
 511     int i, s;
 512     unsigned int *command_ptr;
 513
 514     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 515     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 516
 517     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 518         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 519         int slice_mb_begin = pSliceParameter->macroblock_address;
 520         int slice_mb_number = pSliceParameter->num_macroblocks;
 521         unsigned int mb_intra_ub;
 522         int slice_mb_x = pSliceParameter->macroblock_address % mb_width;
 523         for (i = 0; i < slice_mb_number;  ) {
 524             int mb_count = i + slice_mb_begin;
 525             mb_x = mb_count % mb_width;
 526             mb_y = mb_count / mb_width;
 527             mb_intra_ub = 0;
 528             if (mb_x != 0) {
 529                 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 530             }
 531             if (mb_y != 0) {
 532                 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 533                 if (mb_x != 0)
 534                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 535                 if (mb_x != (mb_width -1))
 536                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 537             }
 538             if (i < mb_width) {
 539                 if (i == 0)
 540                     mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_AE);
 541                 mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_BCD_MASK);
 542                 if ((i == (mb_width - 1)) && slice_mb_x) {
 543                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 544                 }
 545             }
 546
 547             if ((i == mb_width) && slice_mb_x) {
 548                 mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_D);
 549             }
 550             *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 551             *command_ptr++ = kernel;
 552             *command_ptr++ = 0;
 553             *command_ptr++ = 0;
 554             *command_ptr++ = 0;
 555             *command_ptr++ = 0;
 556
 557             /*inline data */
 558             *command_ptr++ = (mb_width << 16 | mb_y << 8 | mb_x);
 559             *command_ptr++ = ( (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 560
 561             *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 562             *command_ptr++ = 0;
 563             i += 1;
 564         }
 565     }
 566
 567     *command_ptr++ = MI_BATCH_BUFFER_END;
 568     *command_ptr++ = 0;
 569
 570     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 571 }
 572
 573 static void gen8_vme_media_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
 574 {
 575     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 576
 577     gen8_gpe_context_init(ctx, &vme_context->gpe_context);
 578
 579     /* VME output buffer */
 580     dri_bo_unreference(vme_context->vme_output.bo);
 581     vme_context->vme_output.bo = NULL;
 582
 583     dri_bo_unreference(vme_context->vme_batchbuffer.bo);
 584     vme_context->vme_batchbuffer.bo = NULL;
 585
 586     /* VME state */
 587     dri_bo_unreference(vme_context->vme_state.bo);
 588     vme_context->vme_state.bo = NULL;
 589 }
 590
 591 static void gen8_vme_pipeline_programing(VADriverContextP ctx,
 592                                          struct encode_state *encode_state,
 593                                          struct intel_encoder_context *encoder_context)
 594 {
 595     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 596     struct intel_batchbuffer *batch = encoder_context->base.batch;
 597     VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
 598     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 599     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 600     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
 601     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
 602     int kernel_shader;
 603     bool allow_hwscore = true;
 604     int s;
 605
 606     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 607         pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 608         if ((pSliceParameter->macroblock_address % width_in_mbs)) {
 609             allow_hwscore = false;
 610             break;
 611         }
 612     }
 613
 614     if ((pSliceParameter->slice_type == SLICE_TYPE_I) ||
 615         (pSliceParameter->slice_type == SLICE_TYPE_I)) {
 616         kernel_shader = VME_INTRA_SHADER;
 617     } else if ((pSliceParameter->slice_type == SLICE_TYPE_P) ||
 618                (pSliceParameter->slice_type == SLICE_TYPE_SP)) {
 619         kernel_shader = VME_INTER_SHADER;
 620     } else {
 621         kernel_shader = VME_BINTER_SHADER;
 622         if (!allow_hwscore)
 623             kernel_shader = VME_INTER_SHADER;
 624     }
 625     if (allow_hwscore)
 626         gen8wa_vme_walker_fill_vme_batchbuffer(ctx,
 627                                              encode_state,
 628                                              width_in_mbs, height_in_mbs,
 629                                              kernel_shader,
 630                                              pPicParameter->pic_fields.bits.transform_8x8_mode_flag,
 631                                              encoder_context);
 632     else
 633         gen8_vme_fill_vme_batchbuffer(ctx,
 634                                       encode_state,
 635                                       width_in_mbs, height_in_mbs,
 636                                       kernel_shader,
 637                                       pPicParameter->pic_fields.bits.transform_8x8_mode_flag,
 638                                       encoder_context);
 639
 640     intel_batchbuffer_start_atomic(batch, 0x1000);
 641     gen8_gpe_pipeline_setup(ctx, &vme_context->gpe_context, batch);
 642     BEGIN_BATCH(batch, 3);
 643     OUT_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8) | (1 << 0));
 644     OUT_RELOC(batch,
 645               vme_context->vme_batchbuffer.bo,
 646               I915_GEM_DOMAIN_COMMAND, 0,
 647               0);
 648     OUT_BATCH(batch, 0);
 649     ADVANCE_BATCH(batch);
 650
 651     intel_batchbuffer_end_atomic(batch);
 652 }
 653
 654 static VAStatus gen8_vme_prepare(VADriverContextP ctx,
 655                                  struct encode_state *encode_state,
 656                                  struct intel_encoder_context *encoder_context)
 657 {
 658     VAStatus vaStatus = VA_STATUS_SUCCESS;
 659     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 660     int is_intra = pSliceParameter->slice_type == SLICE_TYPE_I;
 661     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 662     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 663
 664     if (!vme_context->h264_level ||
 665         (vme_context->h264_level != pSequenceParameter->level_idc)) {
 666         vme_context->h264_level = pSequenceParameter->level_idc;
 667     }
 668
 669     intel_vme_update_mbmv_cost(ctx, encode_state, encoder_context);
 670
 671     /*Setup all the memory object*/
 672     gen8_vme_surface_setup(ctx, encode_state, is_intra, encoder_context);
 673     gen8_vme_interface_setup(ctx, encode_state, encoder_context);
 674     //gen8_vme_vme_state_setup(ctx, encode_state, is_intra, encoder_context);
 675     gen8_vme_constant_setup(ctx, encode_state, encoder_context);
 676
 677     /*Programing media pipeline*/
 678     gen8_vme_pipeline_programing(ctx, encode_state, encoder_context);
 679
 680     return vaStatus;
 681 }
 682
 683 static VAStatus gen8_vme_run(VADriverContextP ctx,
 684                              struct encode_state *encode_state,
 685                              struct intel_encoder_context *encoder_context)
 686 {
 687     struct intel_batchbuffer *batch = encoder_context->base.batch;
 688
 689     intel_batchbuffer_flush(batch);
 690
 691     return VA_STATUS_SUCCESS;
 692 }
 693
 694 static VAStatus gen8_vme_stop(VADriverContextP ctx,
 695                               struct encode_state *encode_state,
 696                               struct intel_encoder_context *encoder_context)
 697 {
 698     return VA_STATUS_SUCCESS;
 699 }
 700
 701 static VAStatus
 702 gen8_vme_pipeline(VADriverContextP ctx,
 703                   VAProfile profile,
 704                   struct encode_state *encode_state,
 705                   struct intel_encoder_context *encoder_context)
 706 {
 707     gen8_vme_media_init(ctx, encoder_context);
 708     gen8_vme_prepare(ctx, encode_state, encoder_context);
 709     gen8_vme_run(ctx, encode_state, encoder_context);
 710     gen8_vme_stop(ctx, encode_state, encoder_context);
 711
 712     return VA_STATUS_SUCCESS;
 713 }
 714
 715 static void
 716 gen8_vme_mpeg2_output_buffer_setup(VADriverContextP ctx,
 717                                    struct encode_state *encode_state,
 718                                    int index,
 719                                    int is_intra,
 720                                    struct intel_encoder_context *encoder_context)
 721
 722 {
 723     struct i965_driver_data *i965 = i965_driver_data(ctx);
 724     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 725     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 726     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 727     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 728
 729     vme_context->vme_output.num_blocks = width_in_mbs * height_in_mbs;
 730     vme_context->vme_output.pitch = 16; /* in bytes, always 16 */
 731
 732     if (is_intra)
 733         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 2;
 734     else
 735         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 24;
 736     /*
 737      * Inter MV . 32-byte Intra search + 16 IME info + 128 IME MV + 32 IME Ref
 738      * + 16 FBR Info + 128 FBR MV + 32 FBR Ref.
 739      * 16 * (2 + 2 * (1 + 8 + 2))= 16 * 24.
 740      */
 741
 742     vme_context->vme_output.bo = dri_bo_alloc(i965->intel.bufmgr,
 743                                               "VME output buffer",
 744                                               vme_context->vme_output.num_blocks * vme_context->vme_output.size_block,
 745                                               0x1000);
 746     assert(vme_context->vme_output.bo);
 747     vme_context->vme_buffer_suface_setup(ctx,
 748                                          &vme_context->gpe_context,
 749                                          &vme_context->vme_output,
 750                                          BINDING_TABLE_OFFSET(index),
 751                                          SURFACE_STATE_OFFSET(index));
 752 }
 753
 754 static void
 755 gen8_vme_mpeg2_output_vme_batchbuffer_setup(VADriverContextP ctx,
 756                                             struct encode_state *encode_state,
 757                                             int index,
 758                                             struct intel_encoder_context *encoder_context)
 759
 760 {
 761     struct i965_driver_data *i965 = i965_driver_data(ctx);
 762     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 763     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 764     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 765     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 766
 767     vme_context->vme_batchbuffer.num_blocks = width_in_mbs * height_in_mbs + 1;
 768     vme_context->vme_batchbuffer.size_block = 64; /* 4 OWORDs */
 769     vme_context->vme_batchbuffer.pitch = 16;
 770     vme_context->vme_batchbuffer.bo = dri_bo_alloc(i965->intel.bufmgr,
 771                                                    "VME batchbuffer",
 772                                                    vme_context->vme_batchbuffer.num_blocks * vme_context->vme_batchbuffer.size_block,
 773                                                    0x1000);
 774     vme_context->vme_buffer_suface_setup(ctx,
 775                                          &vme_context->gpe_context,
 776                                          &vme_context->vme_batchbuffer,
 777                                          BINDING_TABLE_OFFSET(index),
 778                                          SURFACE_STATE_OFFSET(index));
 779 }
 780
 781 static VAStatus
 782 gen8_vme_mpeg2_surface_setup(VADriverContextP ctx,
 783                              struct encode_state *encode_state,
 784                              int is_intra,
 785                              struct intel_encoder_context *encoder_context)
 786 {
 787     struct object_surface *obj_surface;
 788
 789     /*Setup surfaces state*/
 790     /* current picture for encoding */
 791     obj_surface = encode_state->input_yuv_object;
 792     gen8_vme_source_surface_state(ctx, 0, obj_surface, encoder_context);
 793     gen8_vme_media_source_surface_state(ctx, 4, obj_surface, encoder_context);
 794     gen8_vme_media_chroma_source_surface_state(ctx, 6, obj_surface, encoder_context);
 795
 796     if (!is_intra) {
 797         /* reference 0 */
 798         obj_surface = encode_state->reference_objects[0];
 799
 800         if (obj_surface->bo != NULL)
 801             gen8_vme_source_surface_state(ctx, 1, obj_surface, encoder_context);
 802
 803         /* reference 1 */
 804         obj_surface = encode_state->reference_objects[1];
 805
 806         if (obj_surface && obj_surface->bo != NULL)
 807             gen8_vme_source_surface_state(ctx, 2, obj_surface, encoder_context);
 808     }
 809
 810     /* VME output */
 811     gen8_vme_mpeg2_output_buffer_setup(ctx, encode_state, 3, is_intra, encoder_context);
 812     gen8_vme_mpeg2_output_vme_batchbuffer_setup(ctx, encode_state, 5, encoder_context);
 813
 814     return VA_STATUS_SUCCESS;
 815 }
 816
 817 static void
 818 gen8wa_vme_mpeg2_walker_fill_vme_batchbuffer(VADriverContextP ctx,
 819                                            struct encode_state *encode_state,
 820                                            int mb_width, int mb_height,
 821                                            int kernel,
 822                                            struct intel_encoder_context *encoder_context)
 823 {
 824     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 825     unsigned int *command_ptr;
 826
 827 #define         MPEG2_SCOREBOARD                (1 << 21)
 828
 829     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 830     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 831
 832     {
 833         unsigned int mb_intra_ub, score_dep;
 834         int x_outer, y_outer, x_inner, y_inner;
 835         int xtemp_outer = 0;
 836         int first_mb = 0;
 837         int num_mb = mb_width * mb_height;
 838
 839         x_outer = 0;
 840         y_outer = 0;
 841
 842
 843         for (; x_outer < (mb_width -2 ) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 844             x_inner = x_outer;
 845             y_inner = y_outer;
 846             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 847                 mb_intra_ub = 0;
 848                 score_dep = 0;
 849                 if (x_inner != 0) {
 850                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 851                     score_dep |= MB_SCOREBOARD_A;
 852                 }
 853                 if (y_inner != 0) {
 854                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 855                     score_dep |= MB_SCOREBOARD_B;
 856
 857                     if (x_inner != 0)
 858                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 859
 860                     if (x_inner != (mb_width -1)) {
 861                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 862                         score_dep |= MB_SCOREBOARD_C;
 863                     }
 864                 }
 865
 866                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 867                 *command_ptr++ = kernel;
 868                 *command_ptr++ = MPEG2_SCOREBOARD;
 869                 /* Indirect data */
 870                 *command_ptr++ = 0;
 871                 /* the (X, Y) term of scoreboard */
 872                 *command_ptr++ = ((y_inner << 16) | x_inner);
 873                 *command_ptr++ = score_dep;
 874                 /*inline data */
 875                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 876                 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
 877                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 878                 *command_ptr++ = 0;
 879
 880                 x_inner -= 2;
 881                 y_inner += 1;
 882             }
 883             x_outer += 1;
 884         }
 885
 886         xtemp_outer = mb_width - 2;
 887         if (xtemp_outer < 0)
 888             xtemp_outer = 0;
 889         x_outer = xtemp_outer;
 890         y_outer = 0;
 891         for (;!loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height); ) {
 892             y_inner = y_outer;
 893             x_inner = x_outer;
 894             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
 895                 mb_intra_ub = 0;
 896                 score_dep = 0;
 897                 if (x_inner != 0) {
 898                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 899                     score_dep |= MB_SCOREBOARD_A;
 900                 }
 901                 if (y_inner != 0) {
 902                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 903                     score_dep |= MB_SCOREBOARD_B;
 904
 905                     if (x_inner != 0)
 906                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 907
 908                     if (x_inner != (mb_width -1)) {
 909                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 910                         score_dep |= MB_SCOREBOARD_C;
 911                     }
 912                 }
 913
 914                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 915                 *command_ptr++ = kernel;
 916                 *command_ptr++ = MPEG2_SCOREBOARD;
 917                 /* Indirect data */
 918                 *command_ptr++ = 0;
 919                 /* the (X, Y) term of scoreboard */
 920                 *command_ptr++ = ((y_inner << 16) | x_inner);
 921                 *command_ptr++ = score_dep;
 922                 /*inline data */
 923                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
 924                 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
 925
 926                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
 927                 *command_ptr++ = 0;
 928                 x_inner -= 2;
 929                 y_inner += 1;
 930             }
 931             x_outer++;
 932             if (x_outer >= mb_width) {
 933                 y_outer += 1;
 934                 x_outer = xtemp_outer;
 935             }
 936         }
 937     }
 938
 939     *command_ptr++ = MI_BATCH_BUFFER_END;
 940     *command_ptr++ = 0;
 941
 942     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 943     return;
 944 }
 945
 946 static void
 947 gen8_vme_mpeg2_fill_vme_batchbuffer(VADriverContextP ctx,
 948                                     struct encode_state *encode_state,
 949                                     int mb_width, int mb_height,
 950                                     int kernel,
 951                                     int transform_8x8_mode_flag,
 952                                     struct intel_encoder_context *encoder_context)
 953 {
 954     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 955     int mb_x = 0, mb_y = 0;
 956     int i, s, j;
 957     unsigned int *command_ptr;
 958
 959
 960     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 961     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 962
 963     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 964         VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[s]->buffer;
 965
 966         for (j = 0; j < encode_state->slice_params_ext[s]->num_elements; j++) {
 967             int slice_mb_begin = slice_param->macroblock_address;
 968             int slice_mb_number = slice_param->num_macroblocks;
 969             unsigned int mb_intra_ub;
 970
 971             for (i = 0; i < slice_mb_number;) {
 972                 int mb_count = i + slice_mb_begin;
 973
 974                 mb_x = mb_count % mb_width;
 975                 mb_y = mb_count / mb_width;
 976                 mb_intra_ub = 0;
 977
 978                 if (mb_x != 0) {
 979                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 980                 }
 981
 982                 if (mb_y != 0) {
 983                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 984
 985                     if (mb_x != 0)
 986                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 987
 988                     if (mb_x != (mb_width -1))
 989                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 990                 }
 991
 992                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 993                 *command_ptr++ = kernel;
 994                 *command_ptr++ = 0;
 995                 *command_ptr++ = 0;
 996                 *command_ptr++ = 0;
 997                 *command_ptr++ = 0;
 998
 999                 /*inline data */
1000                 *command_ptr++ = (mb_width << 16 | mb_y << 8 | mb_x);
1001                 *command_ptr++ = ( (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
1002
1003                 *command_ptr++ = CMD_MEDIA_STATE_FLUSH;
1004                 *command_ptr++ = 0;
1005                 i += 1;
1006             }
1007
1008             slice_param++;
1009         }
1010     }
1011
1012     *command_ptr++ = MI_BATCH_BUFFER_END;
1013     *command_ptr++ = 0;
1014
1015     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
1016 }
1017
1018 static void
1019 gen8_vme_mpeg2_pipeline_programing(VADriverContextP ctx,
1020                                    struct encode_state *encode_state,
1021                                    int is_intra,
1022                                    struct intel_encoder_context *encoder_context)
1023 {
1024     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1025     struct intel_batchbuffer *batch = encoder_context->base.batch;
1026     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
1027     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
1028     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
1029     bool allow_hwscore = true;
1030     int s;
1031     int kernel_shader;
1032     VAEncPictureParameterBufferMPEG2 *pic_param = NULL;
1033
1034     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
1035         int j;
1036         VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[s]->buffer;
1037
1038         for (j = 0; j < encode_state->slice_params_ext[s]->num_elements; j++) {
1039             if (slice_param->macroblock_address % width_in_mbs) {
1040                 allow_hwscore = false;
1041                 break;
1042             }
1043         }
1044     }
1045
1046     pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
1047     if (pic_param->picture_type == VAEncPictureTypeIntra) {
1048         allow_hwscore = false;
1049         kernel_shader = VME_INTRA_SHADER;
1050     } else {
1051         kernel_shader = VME_INTER_SHADER;
1052     }
1053
1054     if (allow_hwscore)
1055         gen8wa_vme_mpeg2_walker_fill_vme_batchbuffer(ctx,
1056                                                    encode_state,
1057                                                    width_in_mbs, height_in_mbs,
1058                                                    kernel_shader,
1059                                                    encoder_context);
1060     else
1061         gen8_vme_mpeg2_fill_vme_batchbuffer(ctx,
1062                                             encode_state,
1063                                             width_in_mbs, height_in_mbs,
1064                                             is_intra ? VME_INTRA_SHADER : VME_INTER_SHADER,
1065                                             0,
1066                                             encoder_context);
1067
1068     intel_batchbuffer_start_atomic(batch, 0x1000);
1069     gen8_gpe_pipeline_setup(ctx, &vme_context->gpe_context, batch);
1070     BEGIN_BATCH(batch, 4);
1071     OUT_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8) | (1 << 0));
1072     OUT_RELOC(batch,
1073               vme_context->vme_batchbuffer.bo,
1074               I915_GEM_DOMAIN_COMMAND, 0,
1075               0);
1076     OUT_BATCH(batch, 0);
1077     OUT_BATCH(batch, 0);
1078     ADVANCE_BATCH(batch);
1079
1080     intel_batchbuffer_end_atomic(batch);
1081 }
1082
1083 static VAStatus
1084 gen8_vme_mpeg2_prepare(VADriverContextP ctx,
1085                        struct encode_state *encode_state,
1086                        struct intel_encoder_context *encoder_context)
1087 {
1088     VAStatus vaStatus = VA_STATUS_SUCCESS;
1089     VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[0]->buffer;
1090     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
1091     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1092
1093     if ((!vme_context->mpeg2_level) ||
1094         (vme_context->mpeg2_level != (seq_param->sequence_extension.bits.profile_and_level_indication & MPEG2_LEVEL_MASK))) {
1095         vme_context->mpeg2_level = seq_param->sequence_extension.bits.profile_and_level_indication & MPEG2_LEVEL_MASK;
1096     }
1097
1098
1099     /*Setup all the memory object*/
1100     gen8_vme_mpeg2_surface_setup(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
1101     gen8_vme_interface_setup(ctx, encode_state, encoder_context);
1102     //gen8_vme_vme_state_setup(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
1103     intel_vme_mpeg2_state_setup(ctx, encode_state, encoder_context);
1104     gen8_vme_constant_setup(ctx, encode_state, encoder_context);
1105
1106     /*Programing media pipeline*/
1107     gen8_vme_mpeg2_pipeline_programing(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
1108
1109     return vaStatus;
1110 }
1111
1112 static VAStatus
1113 gen8_vme_mpeg2_pipeline(VADriverContextP ctx,
1114                         VAProfile profile,
1115                         struct encode_state *encode_state,
1116                         struct intel_encoder_context *encoder_context)
1117 {
1118     gen8_vme_media_init(ctx, encoder_context);
1119     gen8_vme_mpeg2_prepare(ctx, encode_state, encoder_context);
1120     gen8_vme_run(ctx, encode_state, encoder_context);
1121     gen8_vme_stop(ctx, encode_state, encoder_context);
1122
1123     return VA_STATUS_SUCCESS;
1124 }
1125
1126 static void
1127 gen8_vme_context_destroy(void *context)
1128 {
1129     struct gen6_vme_context *vme_context = context;
1130
1131     gen8_gpe_context_destroy(&vme_context->gpe_context);
1132
1133     dri_bo_unreference(vme_context->vme_output.bo);
1134     vme_context->vme_output.bo = NULL;
1135
1136     dri_bo_unreference(vme_context->vme_state.bo);
1137     vme_context->vme_state.bo = NULL;
1138
1139     dri_bo_unreference(vme_context->vme_batchbuffer.bo);
1140     vme_context->vme_batchbuffer.bo = NULL;
1141
1142     if (vme_context->vme_state_message) {
1143         free(vme_context->vme_state_message);
1144         vme_context->vme_state_message = NULL;
1145     }
1146
1147     free(vme_context);
1148 }
1149
1150 Bool gen8_vme_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
1151 {
1152     struct gen6_vme_context *vme_context = calloc(1, sizeof(struct gen6_vme_context));
1153     struct i965_kernel *vme_kernel_list = NULL;
1154     int i965_kernel_num;
1155
1156     switch (encoder_context->codec) {
1157     case CODEC_H264:
1158         vme_kernel_list = gen8_vme_kernels;
1159         encoder_context->vme_pipeline = gen8_vme_pipeline;
1160         i965_kernel_num = sizeof(gen8_vme_kernels) / sizeof(struct i965_kernel);
1161         break;
1162
1163     case CODEC_MPEG2:
1164         vme_kernel_list = gen8_vme_mpeg2_kernels;
1165         encoder_context->vme_pipeline = gen8_vme_mpeg2_pipeline;
1166         i965_kernel_num = sizeof(gen8_vme_mpeg2_kernels) / sizeof(struct i965_kernel);
1167
1168         break;
1169
1170     default:
1171         /* never get here */
1172         assert(0);
1173
1174         break;
1175     }
1176     vme_context->vme_kernel_sum = i965_kernel_num;
1177     vme_context->gpe_context.surface_state_binding_table.length = (SURFACE_STATE_PADDED_SIZE + sizeof(unsigned int)) * MAX_MEDIA_SURFACES_GEN6;
1178
1179     vme_context->gpe_context.idrt_size = sizeof(struct gen8_interface_descriptor_data) * MAX_INTERFACE_DESC_GEN6;
1180     vme_context->gpe_context.curbe_size = CURBE_TOTAL_DATA_LENGTH;
1181     vme_context->gpe_context.sampler_size = 0;
1182
1183
1184     vme_context->gpe_context.vfe_state.max_num_threads = 60 - 1;
1185     vme_context->gpe_context.vfe_state.num_urb_entries = 64;
1186     vme_context->gpe_context.vfe_state.gpgpu_mode = 0;
1187     vme_context->gpe_context.vfe_state.urb_entry_size = 16;
1188     vme_context->gpe_context.vfe_state.curbe_allocation_size = CURBE_ALLOCATION_SIZE - 1;
1189
1190     gen7_vme_scoreboard_init(ctx, vme_context);
1191
1192     gen8_gpe_load_kernels(ctx,
1193                           &vme_context->gpe_context,
1194                           vme_kernel_list,
1195                           i965_kernel_num);
1196     vme_context->vme_surface2_setup = gen8_gpe_surface2_setup;
1197     vme_context->vme_media_rw_surface_setup = gen8_gpe_media_rw_surface_setup;
1198     vme_context->vme_buffer_suface_setup = gen8_gpe_buffer_suface_setup;
1199     vme_context->vme_media_chroma_surface_setup = gen8_gpe_media_chroma_surface_setup;
1200
1201     encoder_context->vme_context = vme_context;
1202     encoder_context->vme_context_destroy = gen8_vme_context_destroy;
1203
1204     vme_context->vme_state_message = malloc(VME_MSG_LENGTH * sizeof(int));
1205
1206     return True;
1207 }