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