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_frame_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     vme_context->vme_buffer_suface_setup(ctx,
 230                                          &vme_context->gpe_context,
 231                                          &vme_context->vme_batchbuffer,
 232                                          BINDING_TABLE_OFFSET(index),
 233                                          SURFACE_STATE_OFFSET(index));
 234 }
 235
 236 static VAStatus
 237 gen8_vme_surface_setup(VADriverContextP ctx,
 238                         struct encode_state *encode_state,
 239                         int is_intra,
 240                         struct intel_encoder_context *encoder_context)
 241 {
 242     struct object_surface *obj_surface;
 243
 244     /*Setup surfaces state*/
 245     /* current picture for encoding */
 246     obj_surface = encode_state->input_yuv_object;
 247     gen8_vme_source_surface_state(ctx, 0, obj_surface, encoder_context);
 248     gen8_vme_media_source_surface_state(ctx, 4, obj_surface, encoder_context);
 249     gen8_vme_media_chroma_source_surface_state(ctx, 6, obj_surface, encoder_context);
 250
 251     if (!is_intra) {
 252         /* reference 0 */
 253         obj_surface = encode_state->reference_objects[0];
 254
 255         if (obj_surface && obj_surface->bo)
 256             gen8_vme_source_surface_state(ctx, 1, obj_surface, encoder_context);
 257
 258         /* reference 1 */
 259         obj_surface = encode_state->reference_objects[1];
 260
 261         if (obj_surface && obj_surface->bo)
 262             gen8_vme_source_surface_state(ctx, 2, obj_surface, encoder_context);
 263     }
 264
 265     /* VME output */
 266     gen8_vme_output_buffer_setup(ctx, encode_state, 3, encoder_context);
 267     gen8_vme_output_vme_batchbuffer_setup(ctx, encode_state, 5, encoder_context);
 268
 269     return VA_STATUS_SUCCESS;
 270 }
 271
 272 static VAStatus gen8_vme_interface_setup(VADriverContextP ctx,
 273                                           struct encode_state *encode_state,
 274                                           struct intel_encoder_context *encoder_context)
 275 {
 276     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 277     struct gen8_interface_descriptor_data *desc;
 278     int i;
 279     dri_bo *bo;
 280
 281     bo = vme_context->gpe_context.idrt.bo;
 282     dri_bo_map(bo, 1);
 283     assert(bo->virtual);
 284     desc = bo->virtual;
 285
 286     for (i = 0; i < vme_context->vme_kernel_sum; i++) {
 287         struct i965_kernel *kernel;
 288         kernel = &vme_context->gpe_context.kernels[i];
 289         assert(sizeof(*desc) == 32);
 290         /*Setup the descritor table*/
 291         memset(desc, 0, sizeof(*desc));
 292         desc->desc0.kernel_start_pointer = (kernel->bo->offset >> 6);
 293         desc->desc3.sampler_count = 0; /* FIXME: */
 294         desc->desc3.sampler_state_pointer = 0;
 295         desc->desc4.binding_table_entry_count = 1; /* FIXME: */
 296         desc->desc4.binding_table_pointer = (BINDING_TABLE_OFFSET(0) >> 5);
 297         desc->desc5.constant_urb_entry_read_offset = 0;
 298         desc->desc5.constant_urb_entry_read_length = CURBE_URB_ENTRY_LENGTH;
 299
 300
 301         /*kernel start*/
 302         dri_bo_emit_reloc(bo,
 303                           I915_GEM_DOMAIN_INSTRUCTION, 0,
 304                           0,
 305                           i * sizeof(*desc) + offsetof(struct gen8_interface_descriptor_data, desc0),
 306                           kernel->bo);
 307         desc++;
 308     }
 309     dri_bo_unmap(bo);
 310
 311     return VA_STATUS_SUCCESS;
 312 }
 313
 314 static VAStatus gen8_vme_constant_setup(VADriverContextP ctx,
 315                                          struct encode_state *encode_state,
 316                                          struct intel_encoder_context *encoder_context)
 317 {
 318     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 319     unsigned char *constant_buffer;
 320     unsigned int *vme_state_message;
 321     int mv_num = 32;
 322
 323     vme_state_message = (unsigned int *)vme_context->vme_state_message;
 324
 325     if (encoder_context->codec == CODEC_H264) {
 326         if (vme_context->h264_level >= 30) {
 327             mv_num = 16;
 328
 329             if (vme_context->h264_level >= 31)
 330                 mv_num = 8;
 331         }
 332     } else if (encoder_context->codec == CODEC_MPEG2) {
 333         mv_num = 2;
 334     }
 335
 336     vme_state_message[31] = mv_num;
 337
 338     dri_bo_map(vme_context->gpe_context.curbe.bo, 1);
 339     assert(vme_context->gpe_context.curbe.bo->virtual);
 340     constant_buffer = vme_context->gpe_context.curbe.bo->virtual;
 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.curbe.bo);
 349
 350     return VA_STATUS_SUCCESS;
 351 }
 352
 353 static const unsigned int intra_mb_mode_cost_table[] = {
 354     0x31110001, // for qp0
 355     0x09110001, // for qp1
 356     0x15030001, // for qp2
 357     0x0b030001, // for qp3
 358     0x0d030011, // for qp4
 359     0x17210011, // for qp5
 360     0x41210011, // for qp6
 361     0x19210011, // for qp7
 362     0x25050003, // for qp8
 363     0x1b130003, // for qp9
 364     0x1d130003, // for qp10
 365     0x27070021, // for qp11
 366     0x51310021, // for qp12
 367     0x29090021, // for qp13
 368     0x35150005, // for qp14
 369     0x2b0b0013, // for qp15
 370     0x2d0d0013, // for qp16
 371     0x37170007, // for qp17
 372     0x61410031, // for qp18
 373     0x39190009, // for qp19
 374     0x45250015, // for qp20
 375     0x3b1b000b, // for qp21
 376     0x3d1d000d, // for qp22
 377     0x47270017, // for qp23
 378     0x71510041, // for qp24 ! center for qp=0..30
 379     0x49290019, // for qp25
 380     0x55350025, // for qp26
 381     0x4b2b001b, // for qp27
 382     0x4d2d001d, // for qp28
 383     0x57370027, // for qp29
 384     0x81610051, // for qp30
 385     0x57270017, // for qp31
 386     0x81510041, // for qp32 ! center for qp=31..51
 387     0x59290019, // for qp33
 388     0x65350025, // for qp34
 389     0x5b2b001b, // for qp35
 390     0x5d2d001d, // for qp36
 391     0x67370027, // for qp37
 392     0x91610051, // for qp38
 393     0x69390029, // for qp39
 394     0x75450035, // for qp40
 395     0x6b3b002b, // for qp41
 396     0x6d3d002d, // for qp42
 397     0x77470037, // for qp43
 398     0xa1710061, // for qp44
 399     0x79490039, // for qp45
 400     0x85550045, // for qp46
 401     0x7b4b003b, // for qp47
 402     0x7d4d003d, // for qp48
 403     0x87570047, // for qp49
 404     0xb1810071, // for qp50
 405     0x89590049  // for qp51
 406 };
 407
 408 static void gen8_vme_state_setup_fixup(VADriverContextP ctx,
 409                                         struct encode_state *encode_state,
 410                                         struct intel_encoder_context *encoder_context,
 411                                         unsigned int *vme_state_message)
 412 {
 413     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 414     VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
 415     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 416
 417     if (slice_param->slice_type != SLICE_TYPE_I &&
 418         slice_param->slice_type != SLICE_TYPE_SI)
 419         return;
 420     if (encoder_context->rate_control_mode == VA_RC_CQP)
 421         vme_state_message[0] = intra_mb_mode_cost_table[pic_param->pic_init_qp + slice_param->slice_qp_delta];
 422     else
 423         vme_state_message[0] = intra_mb_mode_cost_table[mfc_context->bit_rate_control_context[slice_param->slice_type].QpPrimeY];
 424 }
 425
 426 static VAStatus gen8_vme_vme_state_setup(VADriverContextP ctx,
 427                                           struct encode_state *encode_state,
 428                                           int is_intra,
 429                                           struct intel_encoder_context *encoder_context)
 430 {
 431     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 432     unsigned int *vme_state_message;
 433     int i;
 434
 435     //pass the MV/Mb cost into VME message on HASWell
 436     assert(vme_context->vme_state_message);
 437     vme_state_message = (unsigned int *)vme_context->vme_state_message;
 438
 439     vme_state_message[0] = 0x4a4a4a4a;
 440     vme_state_message[1] = 0x4a4a4a4a;
 441     vme_state_message[2] = 0x4a4a4a4a;
 442     vme_state_message[3] = 0x22120200;
 443     vme_state_message[4] = 0x62524232;
 444
 445     for (i=5; i < 8; i++) {
 446         vme_state_message[i] = 0;
 447     }
 448
 449     switch (encoder_context->codec) {
 450     case CODEC_H264:
 451         gen8_vme_state_setup_fixup(ctx, encode_state, encoder_context, vme_state_message);
 452
 453         break;
 454
 455     default:
 456         /* no fixup */
 457         break;
 458     }
 459
 460     return VA_STATUS_SUCCESS;
 461 }
 462
 463
 464 static void
 465 gen8_vme_fill_vme_batchbuffer(VADriverContextP ctx,
 466                                struct encode_state *encode_state,
 467                                int mb_width, int mb_height,
 468                                int kernel,
 469                                int transform_8x8_mode_flag,
 470                                struct intel_encoder_context *encoder_context)
 471 {
 472     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 473     int mb_x = 0, mb_y = 0;
 474     int i, s;
 475     unsigned int *command_ptr;
 476
 477     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 478     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 479
 480     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 481         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 482         int slice_mb_begin = pSliceParameter->macroblock_address;
 483         int slice_mb_number = pSliceParameter->num_macroblocks;
 484         unsigned int mb_intra_ub;
 485         int slice_mb_x = pSliceParameter->macroblock_address % mb_width;
 486         for (i = 0; i < slice_mb_number;  ) {
 487             int mb_count = i + slice_mb_begin;
 488             mb_x = mb_count % mb_width;
 489             mb_y = mb_count / mb_width;
 490             mb_intra_ub = 0;
 491             if (mb_x != 0) {
 492                 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 493             }
 494             if (mb_y != 0) {
 495                 mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 496                 if (mb_x != 0)
 497                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 498                 if (mb_x != (mb_width -1))
 499                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 500             }
 501             if (i < mb_width) {
 502                 if (i == 0)
 503                     mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_AE);
 504                 mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_BCD_MASK);
 505                 if ((i == (mb_width - 1)) && slice_mb_x) {
 506                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 507                 }
 508             }
 509
 510             if ((i == mb_width) && slice_mb_x) {
 511                 mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_D);
 512             }
 513             *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 514             *command_ptr++ = kernel;
 515             *command_ptr++ = 0;
 516             *command_ptr++ = 0;
 517             *command_ptr++ = 0;
 518             *command_ptr++ = 0;
 519
 520             /*inline data */
 521             *command_ptr++ = (mb_width << 16 | mb_y << 8 | mb_x);
 522             *command_ptr++ = ( (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 523
 524             i += 1;
 525         }
 526     }
 527
 528     *command_ptr++ = 0;
 529     *command_ptr++ = MI_BATCH_BUFFER_END;
 530
 531     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 532 }
 533
 534 static void gen8_vme_media_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
 535 {
 536     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 537
 538     i965_gpe_context_init(ctx, &vme_context->gpe_context);
 539
 540     /* VME output buffer */
 541     dri_bo_unreference(vme_context->vme_output.bo);
 542     vme_context->vme_output.bo = NULL;
 543
 544     dri_bo_unreference(vme_context->vme_batchbuffer.bo);
 545     vme_context->vme_batchbuffer.bo = NULL;
 546
 547     /* VME state */
 548     dri_bo_unreference(vme_context->vme_state.bo);
 549     vme_context->vme_state.bo = NULL;
 550 }
 551
 552 static void gen8_vme_pipeline_programing(VADriverContextP ctx,
 553                                           struct encode_state *encode_state,
 554                                           struct intel_encoder_context *encoder_context)
 555 {
 556     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 557     struct intel_batchbuffer *batch = encoder_context->base.batch;
 558     VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
 559     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 560     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 561     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
 562     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
 563     int kernel_shader;
 564     bool allow_hwscore = true;
 565     int s;
 566
 567     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 568         pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
 569         if ((pSliceParameter->macroblock_address % width_in_mbs)) {
 570                 allow_hwscore = false;
 571                 break;
 572         }
 573     }
 574     if ((pSliceParameter->slice_type == SLICE_TYPE_I) ||
 575         (pSliceParameter->slice_type == SLICE_TYPE_I)) {
 576         kernel_shader = VME_INTRA_SHADER;
 577    } else if ((pSliceParameter->slice_type == SLICE_TYPE_P) ||
 578         (pSliceParameter->slice_type == SLICE_TYPE_SP)) {
 579         kernel_shader = VME_INTER_SHADER;
 580    } else {
 581         kernel_shader = VME_BINTER_SHADER;
 582         if (!allow_hwscore)
 583              kernel_shader = VME_INTER_SHADER;
 584    }
 585     if (allow_hwscore)
 586         gen7_vme_walker_fill_vme_batchbuffer(ctx,
 587                                   encode_state,
 588                                   width_in_mbs, height_in_mbs,
 589                                   kernel_shader,
 590                                   pPicParameter->pic_fields.bits.transform_8x8_mode_flag,
 591                                   encoder_context);
 592     else
 593         gen8_vme_fill_vme_batchbuffer(ctx,
 594                                    encode_state,
 595                                    width_in_mbs, height_in_mbs,
 596                                    kernel_shader,
 597                                    pPicParameter->pic_fields.bits.transform_8x8_mode_flag,
 598                                    encoder_context);
 599
 600     intel_batchbuffer_start_atomic(batch, 0x1000);
 601     gen8_gpe_pipeline_setup(ctx, &vme_context->gpe_context, batch);
 602     BEGIN_BATCH(batch, 3);
 603     OUT_BATCH(batch, MI_BATCH_BUFFER_START | (1 << 8) | (1 << 0));
 604     OUT_RELOC(batch,
 605               vme_context->vme_batchbuffer.bo,
 606               I915_GEM_DOMAIN_COMMAND, 0,
 607               0);
 608     OUT_BATCH(batch, 0);
 609     ADVANCE_BATCH(batch);
 610
 611     intel_batchbuffer_end_atomic(batch);
 612 }
 613
 614 static VAStatus gen8_vme_prepare(VADriverContextP ctx,
 615                                   struct encode_state *encode_state,
 616                                   struct intel_encoder_context *encoder_context)
 617 {
 618     VAStatus vaStatus = VA_STATUS_SUCCESS;
 619     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 620     int is_intra = pSliceParameter->slice_type == SLICE_TYPE_I;
 621     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 622     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 623
 624     if (!vme_context->h264_level ||
 625         (vme_context->h264_level != pSequenceParameter->level_idc)) {
 626         vme_context->h264_level = pSequenceParameter->level_idc;
 627     }
 628
 629     intel_vme_update_mbmv_cost(ctx, encode_state, encoder_context);
 630
 631     /*Setup all the memory object*/
 632     gen8_vme_surface_setup(ctx, encode_state, is_intra, encoder_context);
 633     gen8_vme_interface_setup(ctx, encode_state, encoder_context);
 634     //gen8_vme_vme_state_setup(ctx, encode_state, is_intra, encoder_context);
 635     gen8_vme_constant_setup(ctx, encode_state, encoder_context);
 636
 637     /*Programing media pipeline*/
 638     gen8_vme_pipeline_programing(ctx, encode_state, encoder_context);
 639
 640     return vaStatus;
 641 }
 642
 643 static VAStatus gen8_vme_run(VADriverContextP ctx,
 644                               struct encode_state *encode_state,
 645                               struct intel_encoder_context *encoder_context)
 646 {
 647     struct intel_batchbuffer *batch = encoder_context->base.batch;
 648
 649     intel_batchbuffer_flush(batch);
 650
 651     return VA_STATUS_SUCCESS;
 652 }
 653
 654 static VAStatus gen8_vme_stop(VADriverContextP ctx,
 655                                struct encode_state *encode_state,
 656                                struct intel_encoder_context *encoder_context)
 657 {
 658     return VA_STATUS_SUCCESS;
 659 }
 660
 661 static VAStatus
 662 gen8_vme_pipeline(VADriverContextP ctx,
 663                    VAProfile profile,
 664                    struct encode_state *encode_state,
 665                    struct intel_encoder_context *encoder_context)
 666 {
 667     gen8_vme_media_init(ctx, encoder_context);
 668     gen8_vme_prepare(ctx, encode_state, encoder_context);
 669     gen8_vme_run(ctx, encode_state, encoder_context);
 670     gen8_vme_stop(ctx, encode_state, encoder_context);
 671
 672     return VA_STATUS_SUCCESS;
 673 }
 674
 675 static void
 676 gen8_vme_mpeg2_output_buffer_setup(VADriverContextP ctx,
 677                                     struct encode_state *encode_state,
 678                                     int index,
 679                                     int is_intra,
 680                                     struct intel_encoder_context *encoder_context)
 681
 682 {
 683     struct i965_driver_data *i965 = i965_driver_data(ctx);
 684     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 685     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 686     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 687     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 688
 689     vme_context->vme_output.num_blocks = width_in_mbs * height_in_mbs;
 690     vme_context->vme_output.pitch = 16; /* in bytes, always 16 */
 691
 692     if (is_intra)
 693         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 2;
 694     else
 695         vme_context->vme_output.size_block = INTRA_VME_OUTPUT_IN_BYTES * 24;
 696     /*
 697      * Inter MV . 32-byte Intra search + 16 IME info + 128 IME MV + 32 IME Ref
 698      * + 16 FBR Info + 128 FBR MV + 32 FBR Ref.
 699      * 16 * (2 + 2 * (1 + 8 + 2))= 16 * 24.
 700      */
 701
 702     vme_context->vme_output.bo = dri_bo_alloc(i965->intel.bufmgr,
 703                                               "VME output buffer",
 704                                               vme_context->vme_output.num_blocks * vme_context->vme_output.size_block,
 705                                               0x1000);
 706     assert(vme_context->vme_output.bo);
 707     vme_context->vme_buffer_suface_setup(ctx,
 708                                          &vme_context->gpe_context,
 709                                          &vme_context->vme_output,
 710                                          BINDING_TABLE_OFFSET(index),
 711                                          SURFACE_STATE_OFFSET(index));
 712 }
 713
 714 static void
 715 gen8_vme_mpeg2_output_vme_batchbuffer_setup(VADriverContextP ctx,
 716                                              struct encode_state *encode_state,
 717                                              int index,
 718                                              struct intel_encoder_context *encoder_context)
 719
 720 {
 721     struct i965_driver_data *i965 = i965_driver_data(ctx);
 722     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 723     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 724     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 725     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 726
 727     vme_context->vme_batchbuffer.num_blocks = width_in_mbs * height_in_mbs + 1;
 728     vme_context->vme_batchbuffer.size_block = 64; /* 4 OWORDs */
 729     vme_context->vme_batchbuffer.pitch = 16;
 730     vme_context->vme_batchbuffer.bo = dri_bo_alloc(i965->intel.bufmgr,
 731                                                    "VME batchbuffer",
 732                                                    vme_context->vme_batchbuffer.num_blocks * vme_context->vme_batchbuffer.size_block,
 733                                                    0x1000);
 734     vme_context->vme_buffer_suface_setup(ctx,
 735                                          &vme_context->gpe_context,
 736                                          &vme_context->vme_batchbuffer,
 737                                          BINDING_TABLE_OFFSET(index),
 738                                          SURFACE_STATE_OFFSET(index));
 739 }
 740
 741 static VAStatus
 742 gen8_vme_mpeg2_surface_setup(VADriverContextP ctx,
 743                               struct encode_state *encode_state,
 744                               int is_intra,
 745                               struct intel_encoder_context *encoder_context)
 746 {
 747     struct object_surface *obj_surface;
 748
 749     /*Setup surfaces state*/
 750     /* current picture for encoding */
 751     obj_surface = encode_state->input_yuv_object;
 752     gen8_vme_source_surface_state(ctx, 0, obj_surface, encoder_context);
 753     gen8_vme_media_source_surface_state(ctx, 4, obj_surface, encoder_context);
 754     gen8_vme_media_chroma_source_surface_state(ctx, 6, obj_surface, encoder_context);
 755
 756     if (!is_intra) {
 757         /* reference 0 */
 758         obj_surface = encode_state->reference_objects[0];
 759
 760         if (obj_surface->bo != NULL)
 761             gen8_vme_source_surface_state(ctx, 1, obj_surface, encoder_context);
 762
 763         /* reference 1 */
 764         obj_surface = encode_state->reference_objects[1];
 765
 766         if (obj_surface && obj_surface->bo != NULL)
 767             gen8_vme_source_surface_state(ctx, 2, obj_surface, encoder_context);
 768     }
 769
 770     /* VME output */
 771     gen8_vme_mpeg2_output_buffer_setup(ctx, encode_state, 3, is_intra, encoder_context);
 772     gen8_vme_mpeg2_output_vme_batchbuffer_setup(ctx, encode_state, 5, encoder_context);
 773
 774     return VA_STATUS_SUCCESS;
 775 }
 776
 777 static void
 778 gen8_vme_mpeg2_fill_vme_batchbuffer(VADriverContextP ctx,
 779                                      struct encode_state *encode_state,
 780                                      int mb_width, int mb_height,
 781                                      int kernel,
 782                                      int transform_8x8_mode_flag,
 783                                      struct intel_encoder_context *encoder_context)
 784 {
 785     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 786     int mb_x = 0, mb_y = 0;
 787     int i, s, j;
 788     unsigned int *command_ptr;
 789
 790
 791     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
 792     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
 793
 794     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
 795         VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[s]->buffer;
 796
 797         for (j = 0; j < encode_state->slice_params_ext[s]->num_elements; j++) {
 798             int slice_mb_begin = slice_param->macroblock_address;
 799             int slice_mb_number = slice_param->num_macroblocks;
 800             unsigned int mb_intra_ub;
 801             int slice_mb_x = slice_param->macroblock_address % mb_width;
 802
 803             for (i = 0; i < slice_mb_number;) {
 804                 int mb_count = i + slice_mb_begin;
 805
 806                 mb_x = mb_count % mb_width;
 807                 mb_y = mb_count / mb_width;
 808                 mb_intra_ub = 0;
 809
 810                 if (mb_x != 0) {
 811                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
 812                 }
 813
 814                 if (mb_y != 0) {
 815                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
 816
 817                     if (mb_x != 0)
 818                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
 819
 820                     if (mb_x != (mb_width -1))
 821                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 822                 }
 823
 824                 if (i < mb_width) {
 825                     if (i == 0)
 826                         mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_AE);
 827
 828                     mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_BCD_MASK);
 829
 830                     if ((i == (mb_width - 1)) && slice_mb_x) {
 831                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
 832                     }
 833                 }
 834
 835                 if ((i == mb_width) && slice_mb_x) {
 836                     mb_intra_ub &= ~(INTRA_PRED_AVAIL_FLAG_D);
 837                 }
 838
 839                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
 840                 *command_ptr++ = kernel;
 841                 *command_ptr++ = 0;
 842                 *command_ptr++ = 0;
 843                 *command_ptr++ = 0;
 844                 *command_ptr++ = 0;
 845
 846                 /*inline data */
 847                 *command_ptr++ = (mb_width << 16 | mb_y << 8 | mb_x);
 848                 *command_ptr++ = ( (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
 849
 850                 i += 1;
 851             }
 852
 853             slice_param++;
 854         }
 855     }
 856
 857     *command_ptr++ = 0;
 858     *command_ptr++ = MI_BATCH_BUFFER_END;
 859
 860     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
 861 }
 862
 863 static void
 864 gen8_vme_mpeg2_pipeline_programing(VADriverContextP ctx,
 865                                     struct encode_state *encode_state,
 866                                     int is_intra,
 867                                     struct intel_encoder_context *encoder_context)
 868 {
 869     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 870     struct intel_batchbuffer *batch = encoder_context->base.batch;
 871     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
 872     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
 873     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
 874
 875     gen8_vme_mpeg2_fill_vme_batchbuffer(ctx,
 876                                          encode_state,
 877                                          width_in_mbs, height_in_mbs,
 878                                          is_intra ? VME_INTRA_SHADER : VME_INTER_SHADER,
 879                                          0,
 880                                          encoder_context);
 881
 882     intel_batchbuffer_start_atomic(batch, 0x1000);
 883     gen8_gpe_pipeline_setup(ctx, &vme_context->gpe_context, batch);
 884     BEGIN_BATCH(batch, 2);
 885     OUT_BATCH(batch, MI_BATCH_BUFFER_START | (2 << 6));
 886     OUT_RELOC(batch,
 887               vme_context->vme_batchbuffer.bo,
 888               I915_GEM_DOMAIN_COMMAND, 0,
 889               0);
 890     ADVANCE_BATCH(batch);
 891
 892     intel_batchbuffer_end_atomic(batch);
 893 }
 894
 895 static VAStatus
 896 gen8_vme_mpeg2_prepare(VADriverContextP ctx,
 897                         struct encode_state *encode_state,
 898                         struct intel_encoder_context *encoder_context)
 899 {
 900     VAStatus vaStatus = VA_STATUS_SUCCESS;
 901     VAEncSliceParameterBufferMPEG2 *slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[0]->buffer;
 902
 903     /*Setup all the memory object*/
 904     gen8_vme_mpeg2_surface_setup(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
 905     gen8_vme_interface_setup(ctx, encode_state, encoder_context);
 906     gen8_vme_vme_state_setup(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
 907     gen8_vme_constant_setup(ctx, encode_state, encoder_context);
 908
 909     /*Programing media pipeline*/
 910     gen8_vme_mpeg2_pipeline_programing(ctx, encode_state, slice_param->is_intra_slice, encoder_context);
 911
 912     return vaStatus;
 913 }
 914
 915 static VAStatus
 916 gen8_vme_mpeg2_pipeline(VADriverContextP ctx,
 917                          VAProfile profile,
 918                          struct encode_state *encode_state,
 919                          struct intel_encoder_context *encoder_context)
 920 {
 921     gen8_vme_media_init(ctx, encoder_context);
 922     gen8_vme_mpeg2_prepare(ctx, encode_state, encoder_context);
 923     gen8_vme_run(ctx, encode_state, encoder_context);
 924     gen8_vme_stop(ctx, encode_state, encoder_context);
 925
 926     return VA_STATUS_SUCCESS;
 927 }
 928
 929 static void
 930 gen8_vme_context_destroy(void *context)
 931 {
 932     struct gen6_vme_context *vme_context = context;
 933
 934     i965_gpe_context_destroy(&vme_context->gpe_context);
 935
 936     dri_bo_unreference(vme_context->vme_output.bo);
 937     vme_context->vme_output.bo = NULL;
 938
 939     dri_bo_unreference(vme_context->vme_state.bo);
 940     vme_context->vme_state.bo = NULL;
 941
 942     dri_bo_unreference(vme_context->vme_batchbuffer.bo);
 943     vme_context->vme_batchbuffer.bo = NULL;
 944
 945     if (vme_context->vme_state_message) {
 946         free(vme_context->vme_state_message);
 947         vme_context->vme_state_message = NULL;
 948     }
 949
 950     free(vme_context);
 951 }
 952
 953 Bool gen8_vme_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
 954 {
 955     struct gen6_vme_context *vme_context = calloc(1, sizeof(struct gen6_vme_context));
 956     struct i965_kernel *vme_kernel_list = NULL;
 957         int i965_kernel_num;
 958
 959     switch (encoder_context->codec) {
 960     case CODEC_H264:
 961         vme_kernel_list = gen8_vme_kernels;
 962         encoder_context->vme_pipeline = gen8_vme_pipeline;
 963         i965_kernel_num = sizeof(gen8_vme_kernels) / sizeof(struct i965_kernel);
 964         break;
 965
 966     case CODEC_MPEG2:
 967         vme_kernel_list = gen8_vme_mpeg2_kernels;
 968         encoder_context->vme_pipeline = gen8_vme_mpeg2_pipeline;
 969         i965_kernel_num = sizeof(gen8_vme_mpeg2_kernels) / sizeof(struct i965_kernel);
 970
 971         break;
 972
 973     default:
 974         /* never get here */
 975         assert(0);
 976
 977         break;
 978     }
 979     vme_context->vme_kernel_sum = i965_kernel_num;
 980     vme_context->gpe_context.surface_state_binding_table.length = (SURFACE_STATE_PADDED_SIZE + sizeof(unsigned int)) * MAX_MEDIA_SURFACES_GEN6;
 981
 982     vme_context->gpe_context.idrt.max_entries = MAX_INTERFACE_DESC_GEN6;
 983     vme_context->gpe_context.idrt.entry_size = sizeof(struct gen8_interface_descriptor_data);
 984
 985     vme_context->gpe_context.curbe.length = CURBE_TOTAL_DATA_LENGTH;
 986
 987     vme_context->gpe_context.vfe_state.max_num_threads = 60 - 1;
 988     vme_context->gpe_context.vfe_state.num_urb_entries = 16;
 989     vme_context->gpe_context.vfe_state.gpgpu_mode = 0;
 990     vme_context->gpe_context.vfe_state.urb_entry_size = 59 - 1;
 991     vme_context->gpe_context.vfe_state.curbe_allocation_size = CURBE_ALLOCATION_SIZE - 1;
 992
 993     gen7_vme_scoreboard_init(ctx, vme_context);
 994
 995     i965_gpe_load_kernels(ctx,
 996                           &vme_context->gpe_context,
 997                           vme_kernel_list,
 998                           i965_kernel_num);
 999     vme_context->vme_surface2_setup = gen8_gpe_surface2_setup;
1000     vme_context->vme_media_rw_surface_setup = gen8_gpe_media_rw_surface_setup;
1001     vme_context->vme_buffer_suface_setup = gen8_gpe_buffer_suface_setup;
1002     vme_context->vme_media_chroma_surface_setup = gen8_gpe_media_chroma_surface_setup;
1003
1004     encoder_context->vme_context = vme_context;
1005     encoder_context->vme_context_destroy = gen8_vme_context_destroy;
1006
1007     vme_context->vme_state_message = malloc(VME_MSG_LENGTH * sizeof(int));
1008
1009     return True;
1010 }