src/gen6_mfc_common.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  *    Xiang Haihao <haihao.xiang@intel.com>
  26  *    Zhao Yakui <yakui.zhao@intel.com>
  27  *
  28  */
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <assert.h>
  34 #include <math.h>
  35
  36 #include "intel_batchbuffer.h"
  37 #include "i965_defines.h"
  38 #include "i965_structs.h"
  39 #include "i965_drv_video.h"
  40 #include "i965_encoder.h"
  41 #include "i965_encoder_utils.h"
  42 #include "gen6_mfc.h"
  43 #include "gen6_vme.h"
  44 #include "gen9_mfc.h"
  45 #include "intel_media.h"
  46
  47 #ifndef HAVE_LOG2F
  48 #define log2f(x) (logf(x)/(float)M_LN2)
  49 #endif
  50
  51 int intel_avc_enc_slice_type_fixup(int slice_type)
  52 {
  53     if (slice_type == SLICE_TYPE_SP ||
  54         slice_type == SLICE_TYPE_P)
  55         slice_type = SLICE_TYPE_P;
  56     else if (slice_type == SLICE_TYPE_SI ||
  57              slice_type == SLICE_TYPE_I)
  58         slice_type = SLICE_TYPE_I;
  59     else {
  60         if (slice_type != SLICE_TYPE_B)
  61             WARN_ONCE("Invalid slice type for H.264 encoding!\n");
  62
  63         slice_type = SLICE_TYPE_B;
  64     }
  65
  66     return slice_type;
  67 }
  68
  69 static void
  70 intel_mfc_bit_rate_control_context_init(struct encode_state *encode_state,
  71                                         struct intel_encoder_context *encoder_context)
  72 {
  73     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
  74     int i;
  75
  76     for (i = 0 ; i < 3; i++) {
  77         mfc_context->bit_rate_control_context[i].MaxQpNegModifier = 6;
  78         mfc_context->bit_rate_control_context[i].MaxQpPosModifier = 6;
  79         mfc_context->bit_rate_control_context[i].GrowInit = 6;
  80         mfc_context->bit_rate_control_context[i].GrowResistance = 4;
  81         mfc_context->bit_rate_control_context[i].ShrinkInit = 6;
  82         mfc_context->bit_rate_control_context[i].ShrinkResistance = 4;
  83
  84         mfc_context->bit_rate_control_context[i].Correct[0] = 8;
  85         mfc_context->bit_rate_control_context[i].Correct[1] = 4;
  86         mfc_context->bit_rate_control_context[i].Correct[2] = 2;
  87         mfc_context->bit_rate_control_context[i].Correct[3] = 2;
  88         mfc_context->bit_rate_control_context[i].Correct[4] = 4;
  89         mfc_context->bit_rate_control_context[i].Correct[5] = 8;
  90     }
  91 }
  92
  93 static void intel_mfc_brc_init(struct encode_state *encode_state,
  94                                struct intel_encoder_context* encoder_context)
  95 {
  96     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
  97     double bitrate, framerate;
  98     double frame_per_bits = 8 * 3 * encoder_context->frame_width_in_pixel * encoder_context->frame_height_in_pixel / 2;
  99     double qp1_size = 0.1 * frame_per_bits;
 100     double qp51_size = 0.001 * frame_per_bits;
 101     int min_qp = MAX(1, encoder_context->brc.min_qp);
 102     double bpf, factor, hrd_factor;
 103     int inum = encoder_context->brc.num_iframes_in_gop,
 104         pnum = encoder_context->brc.num_pframes_in_gop,
 105         bnum = encoder_context->brc.num_bframes_in_gop; /* Gop structure: number of I, P, B frames in the Gop. */
 106     int intra_period = encoder_context->brc.gop_size;
 107     int i;
 108     int tmp_min_qp = 0;
 109
 110     if (encoder_context->layer.num_layers > 1)
 111         qp1_size = 0.15 * frame_per_bits;
 112
 113     mfc_context->brc.mode = encoder_context->rate_control_mode;
 114
 115     mfc_context->hrd.violation_noted = 0;
 116
 117     for (i = 0; i < encoder_context->layer.num_layers; i++) {
 118         mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I] = 26;
 119         mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 26;
 120         mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B] = 26;
 121
 122         if (i == 0) {
 123             bitrate = encoder_context->brc.bits_per_second[0];
 124             framerate = (double)encoder_context->brc.framerate[0].num / (double)encoder_context->brc.framerate[0].den;
 125         } else {
 126             bitrate = (encoder_context->brc.bits_per_second[i] - encoder_context->brc.bits_per_second[i - 1]);
 127             framerate = ((double)encoder_context->brc.framerate[i].num / (double)encoder_context->brc.framerate[i].den) -
 128                         ((double)encoder_context->brc.framerate[i - 1].num / (double)encoder_context->brc.framerate[i - 1].den);
 129         }
 130
 131         if (mfc_context->brc.mode == VA_RC_VBR && encoder_context->brc.target_percentage[i])
 132             bitrate = bitrate * encoder_context->brc.target_percentage[i] / 100;
 133
 134         if (i == encoder_context->layer.num_layers - 1)
 135             factor = 1.0;
 136         else {
 137             factor = ((double)encoder_context->brc.framerate[i].num / (double)encoder_context->brc.framerate[i].den) /
 138                      ((double)encoder_context->brc.framerate[i - 1].num / (double)encoder_context->brc.framerate[i - 1].den);
 139         }
 140
 141         hrd_factor = (double)bitrate / encoder_context->brc.bits_per_second[encoder_context->layer.num_layers - 1];
 142
 143         mfc_context->hrd.buffer_size[i] = (unsigned int)(encoder_context->brc.hrd_buffer_size * hrd_factor);
 144         mfc_context->hrd.current_buffer_fullness[i] =
 145             (double)(encoder_context->brc.hrd_initial_buffer_fullness < encoder_context->brc.hrd_buffer_size) ?
 146             encoder_context->brc.hrd_initial_buffer_fullness : encoder_context->brc.hrd_buffer_size / 2.;
 147         mfc_context->hrd.current_buffer_fullness[i] *= hrd_factor;
 148         mfc_context->hrd.target_buffer_fullness[i] = (double)encoder_context->brc.hrd_buffer_size * hrd_factor / 2.;
 149         mfc_context->hrd.buffer_capacity[i] = (double)encoder_context->brc.hrd_buffer_size * hrd_factor / qp1_size;
 150
 151         if (encoder_context->layer.num_layers > 1) {
 152             if (i == 0) {
 153                 intra_period = (int)(encoder_context->brc.gop_size * factor);
 154                 inum = 1;
 155                 pnum = (int)(encoder_context->brc.num_pframes_in_gop * factor);
 156                 bnum = intra_period - inum - pnum;
 157             } else {
 158                 intra_period = (int)(encoder_context->brc.gop_size * factor) - intra_period;
 159                 inum = 0;
 160                 pnum = (int)(encoder_context->brc.num_pframes_in_gop * factor) - pnum;
 161                 bnum = intra_period - inum - pnum;
 162             }
 163         }
 164
 165         mfc_context->brc.gop_nums[i][SLICE_TYPE_I] = inum;
 166         mfc_context->brc.gop_nums[i][SLICE_TYPE_P] = pnum;
 167         mfc_context->brc.gop_nums[i][SLICE_TYPE_B] = bnum;
 168
 169         mfc_context->brc.target_frame_size[i][SLICE_TYPE_I] = (int)((double)((bitrate * intra_period) / framerate) /
 170                                                                     (double)(inum + BRC_PWEIGHT * pnum + BRC_BWEIGHT * bnum));
 171         mfc_context->brc.target_frame_size[i][SLICE_TYPE_P] = BRC_PWEIGHT * mfc_context->brc.target_frame_size[i][SLICE_TYPE_I];
 172         mfc_context->brc.target_frame_size[i][SLICE_TYPE_B] = BRC_BWEIGHT * mfc_context->brc.target_frame_size[i][SLICE_TYPE_I];
 173
 174         bpf = mfc_context->brc.bits_per_frame[i] = bitrate / framerate;
 175
 176         if (encoder_context->brc.initial_qp) {
 177             mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I] = encoder_context->brc.initial_qp;
 178             mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = encoder_context->brc.initial_qp;
 179             mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B] = encoder_context->brc.initial_qp;
 180
 181             BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I], min_qp, 51);
 182             BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P], min_qp, 51);
 183             BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B], min_qp, 51);
 184         } else {
 185             if ((bpf > qp51_size) && (bpf < qp1_size)) {
 186                 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 51 - 50 * (bpf - qp51_size) / (qp1_size - qp51_size);
 187             } else if (bpf >= qp1_size)
 188                 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 1;
 189             else if (bpf <= qp51_size)
 190                 mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P] = 51;
 191
 192             mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I] = mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P];
 193             mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B] = mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I];
 194
 195             tmp_min_qp = (min_qp < 36) ? min_qp : 36;
 196             BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_I], tmp_min_qp, 36);
 197             tmp_min_qp = (min_qp < 40) ? min_qp : 40;
 198             BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_P], tmp_min_qp, 40);
 199             tmp_min_qp = (min_qp < 45) ? min_qp : 45;
 200             BRC_CLIP(mfc_context->brc.qp_prime_y[i][SLICE_TYPE_B], tmp_min_qp, 45);
 201         }
 202     }
 203 }
 204
 205 int intel_mfc_update_hrd(struct encode_state *encode_state,
 206                          struct intel_encoder_context *encoder_context,
 207                          int frame_bits)
 208 {
 209     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 210     int layer_id = encoder_context->layer.curr_frame_layer_id;
 211     double prev_bf = mfc_context->hrd.current_buffer_fullness[layer_id];
 212
 213     mfc_context->hrd.current_buffer_fullness[layer_id] -= frame_bits;
 214
 215     if (mfc_context->hrd.buffer_size[layer_id] > 0 && mfc_context->hrd.current_buffer_fullness[layer_id] <= 0.) {
 216         mfc_context->hrd.current_buffer_fullness[layer_id] = prev_bf;
 217         return BRC_UNDERFLOW;
 218     }
 219
 220     mfc_context->hrd.current_buffer_fullness[layer_id] += mfc_context->brc.bits_per_frame[layer_id];
 221     if (mfc_context->hrd.buffer_size[layer_id] > 0 && mfc_context->hrd.current_buffer_fullness[layer_id] > mfc_context->hrd.buffer_size[layer_id]) {
 222         if (mfc_context->brc.mode == VA_RC_VBR)
 223             mfc_context->hrd.current_buffer_fullness[layer_id] = mfc_context->hrd.buffer_size[layer_id];
 224         else {
 225             mfc_context->hrd.current_buffer_fullness[layer_id] = prev_bf;
 226             return BRC_OVERFLOW;
 227         }
 228     }
 229     return BRC_NO_HRD_VIOLATION;
 230 }
 231
 232 static int intel_mfc_brc_postpack_cbr(struct encode_state *encode_state,
 233                                       struct intel_encoder_context *encoder_context,
 234                                       int frame_bits)
 235 {
 236     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 237     gen6_brc_status sts = BRC_NO_HRD_VIOLATION;
 238     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 239     int slicetype = intel_avc_enc_slice_type_fixup(pSliceParameter->slice_type);
 240     int curr_frame_layer_id, next_frame_layer_id;
 241     int qpi, qpp, qpb;
 242     int qp; // quantizer of previously encoded slice of current type
 243     int qpn; // predicted quantizer for next frame of current type in integer format
 244     double qpf; // predicted quantizer for next frame of current type in float format
 245     double delta_qp; // QP correction
 246     int min_qp = MAX(1, encoder_context->brc.min_qp);
 247     int target_frame_size, frame_size_next;
 248     /* Notes:
 249      *  x - how far we are from HRD buffer borders
 250      *  y - how far we are from target HRD buffer fullness
 251      */
 252     double x, y;
 253     double frame_size_alpha;
 254
 255     if (encoder_context->layer.num_layers < 2 || encoder_context->layer.size_frame_layer_ids == 0) {
 256         curr_frame_layer_id = 0;
 257         next_frame_layer_id = 0;
 258     } else {
 259         curr_frame_layer_id = encoder_context->layer.curr_frame_layer_id;
 260         next_frame_layer_id = encoder_context->layer.frame_layer_ids[encoder_context->num_frames_in_sequence % encoder_context->layer.size_frame_layer_ids];
 261     }
 262
 263     /* checking wthether HRD compliance first */
 264     sts = intel_mfc_update_hrd(encode_state, encoder_context, frame_bits);
 265
 266     if (sts == BRC_NO_HRD_VIOLATION) { // no HRD violation
 267         /* nothing */
 268     } else {
 269         next_frame_layer_id = curr_frame_layer_id;
 270     }
 271
 272     mfc_context->brc.bits_prev_frame[curr_frame_layer_id] = frame_bits;
 273     frame_bits = mfc_context->brc.bits_prev_frame[next_frame_layer_id];
 274
 275     mfc_context->brc.prev_slice_type[curr_frame_layer_id] = slicetype;
 276     slicetype = mfc_context->brc.prev_slice_type[next_frame_layer_id];
 277
 278     /* 0 means the next frame is the first frame of next layer */
 279     if (frame_bits == 0)
 280         return sts;
 281
 282     qpi = mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I];
 283     qpp = mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P];
 284     qpb = mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B];
 285
 286     qp = mfc_context->brc.qp_prime_y[next_frame_layer_id][slicetype];
 287
 288     target_frame_size = mfc_context->brc.target_frame_size[next_frame_layer_id][slicetype];
 289     if (mfc_context->hrd.buffer_capacity[next_frame_layer_id] < 5)
 290         frame_size_alpha = 0;
 291     else
 292         frame_size_alpha = (double)mfc_context->brc.gop_nums[next_frame_layer_id][slicetype];
 293     if (frame_size_alpha > 30) frame_size_alpha = 30;
 294     frame_size_next = target_frame_size + (double)(target_frame_size - frame_bits) /
 295                       (double)(frame_size_alpha + 1.);
 296
 297     /* frame_size_next: avoiding negative number and too small value */
 298     if ((double)frame_size_next < (double)(target_frame_size * 0.25))
 299         frame_size_next = (int)((double)target_frame_size * 0.25);
 300
 301     qpf = (double)qp * target_frame_size / frame_size_next;
 302     qpn = (int)(qpf + 0.5);
 303
 304     if (qpn == qp) {
 305         /* setting qpn we round qpf making mistakes: now we are trying to compensate this */
 306         mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] += qpf - qpn;
 307         if (mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] > 1.0) {
 308             qpn++;
 309             mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] = 0.;
 310         } else if (mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] < -1.0) {
 311             qpn--;
 312             mfc_context->brc.qpf_rounding_accumulator[next_frame_layer_id] = 0.;
 313         }
 314     }
 315     /* making sure that QP is not changing too fast */
 316     if ((qpn - qp) > BRC_QP_MAX_CHANGE) qpn = qp + BRC_QP_MAX_CHANGE;
 317     else if ((qpn - qp) < -BRC_QP_MAX_CHANGE) qpn = qp - BRC_QP_MAX_CHANGE;
 318     /* making sure that with QP predictions we did do not leave QPs range */
 319     BRC_CLIP(qpn, 1, 51);
 320
 321     /* calculating QP delta as some function*/
 322     x = mfc_context->hrd.target_buffer_fullness[next_frame_layer_id] - mfc_context->hrd.current_buffer_fullness[next_frame_layer_id];
 323     if (x > 0) {
 324         x /= mfc_context->hrd.target_buffer_fullness[next_frame_layer_id];
 325         y = mfc_context->hrd.current_buffer_fullness[next_frame_layer_id];
 326     } else {
 327         x /= (mfc_context->hrd.buffer_size[next_frame_layer_id] - mfc_context->hrd.target_buffer_fullness[next_frame_layer_id]);
 328         y = mfc_context->hrd.buffer_size[next_frame_layer_id] - mfc_context->hrd.current_buffer_fullness[next_frame_layer_id];
 329     }
 330     if (y < 0.01) y = 0.01;
 331     if (x > 1) x = 1;
 332     else if (x < -1) x = -1;
 333
 334     delta_qp = BRC_QP_MAX_CHANGE * exp(-1 / y) * sin(BRC_PI_0_5 * x);
 335     qpn = (int)(qpn + delta_qp + 0.5);
 336
 337     /* making sure that with QP predictions we did do not leave QPs range */
 338     BRC_CLIP(qpn, min_qp, 51);
 339
 340     if (sts == BRC_NO_HRD_VIOLATION) { // no HRD violation
 341         /* correcting QPs of slices of other types */
 342         if (slicetype == SLICE_TYPE_P) {
 343             if (abs(qpn + BRC_P_B_QP_DIFF - qpb) > 2)
 344                 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B] += (qpn + BRC_P_B_QP_DIFF - qpb) >> 1;
 345             if (abs(qpn - BRC_I_P_QP_DIFF - qpi) > 2)
 346                 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I] += (qpn - BRC_I_P_QP_DIFF - qpi) >> 1;
 347         } else if (slicetype == SLICE_TYPE_I) {
 348             if (abs(qpn + BRC_I_B_QP_DIFF - qpb) > 4)
 349                 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B] += (qpn + BRC_I_B_QP_DIFF - qpb) >> 2;
 350             if (abs(qpn + BRC_I_P_QP_DIFF - qpp) > 2)
 351                 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P] += (qpn + BRC_I_P_QP_DIFF - qpp) >> 2;
 352         } else { // SLICE_TYPE_B
 353             if (abs(qpn - BRC_P_B_QP_DIFF - qpp) > 2)
 354                 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P] += (qpn - BRC_P_B_QP_DIFF - qpp) >> 1;
 355             if (abs(qpn - BRC_I_B_QP_DIFF - qpi) > 4)
 356                 mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I] += (qpn - BRC_I_B_QP_DIFF - qpi) >> 2;
 357         }
 358         BRC_CLIP(mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_I], min_qp, 51);
 359         BRC_CLIP(mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_P], min_qp, 51);
 360         BRC_CLIP(mfc_context->brc.qp_prime_y[next_frame_layer_id][SLICE_TYPE_B], min_qp, 51);
 361     } else if (sts == BRC_UNDERFLOW) { // underflow
 362         if (qpn <= qp) qpn = qp + 1;
 363         if (qpn > 51) {
 364             qpn = 51;
 365             sts = BRC_UNDERFLOW_WITH_MAX_QP; //underflow with maxQP
 366         }
 367     } else if (sts == BRC_OVERFLOW) {
 368         if (qpn >= qp) qpn = qp - 1;
 369         if (qpn < min_qp) { // overflow with minQP
 370             qpn = min_qp;
 371             sts = BRC_OVERFLOW_WITH_MIN_QP; // bit stuffing to be done
 372         }
 373     }
 374
 375     mfc_context->brc.qp_prime_y[next_frame_layer_id][slicetype] = qpn;
 376
 377     return sts;
 378 }
 379
 380 static int intel_mfc_brc_postpack_vbr(struct encode_state *encode_state,
 381                                       struct intel_encoder_context *encoder_context,
 382                                       int frame_bits)
 383 {
 384     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 385     gen6_brc_status sts;
 386     VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 387     int slice_type = intel_avc_enc_slice_type_fixup(pSliceParameter->slice_type);
 388     int *qp = mfc_context->brc.qp_prime_y[0];
 389     int min_qp = MAX(1, encoder_context->brc.min_qp);
 390     int qp_delta, large_frame_adjustment;
 391
 392     // This implements a simple reactive VBR rate control mode for single-layer H.264.  The primary
 393     // aim here is to avoid the problematic behaviour that the CBR rate controller displays on
 394     // scene changes, where the QP can get pushed up by a large amount in a short period and
 395     // compromise the quality of following frames to a very visible degree.
 396     // The main idea, then, is to try to keep the HRD buffering above the target level most of the
 397     // time, so that when a large frame is generated (on a scene change or when the stream
 398     // complexity increases) we have plenty of slack to be able to encode the more difficult region
 399     // without compromising quality immediately on the following frames.   It is optimistic about
 400     // the complexity of future frames, so even after generating one or more large frames on a
 401     // significant change it will try to keep the QP at its current level until the HRD buffer
 402     // bounds force a change to maintain the intended rate.
 403
 404     sts = intel_mfc_update_hrd(encode_state, encoder_context, frame_bits);
 405
 406     // This adjustment is applied to increase the QP by more than we normally would if a very
 407     // large frame is encountered and we are in danger of running out of slack.
 408     large_frame_adjustment = rint(2.0 * log(frame_bits / mfc_context->brc.target_frame_size[0][slice_type]));
 409
 410     if (sts == BRC_UNDERFLOW) {
 411         // The frame is far too big and we don't have the bits available to send it, so it will
 412         // have to be re-encoded at a higher QP.
 413         qp_delta = +2;
 414         if (frame_bits > mfc_context->brc.target_frame_size[0][slice_type])
 415             qp_delta += large_frame_adjustment;
 416     } else if (sts == BRC_OVERFLOW) {
 417         // The frame is very small and we are now overflowing the HRD buffer.  Currently this case
 418         // does not occur because we ignore overflow in VBR mode.
 419         assert(0 && "Overflow in VBR mode");
 420     } else if (frame_bits <= mfc_context->brc.target_frame_size[0][slice_type]) {
 421         // The frame is smaller than the average size expected for this frame type.
 422         if (mfc_context->hrd.current_buffer_fullness[0] >
 423             (mfc_context->hrd.target_buffer_fullness[0] + mfc_context->hrd.buffer_size[0]) / 2.0) {
 424             // We currently have lots of bits available, so decrease the QP slightly for the next
 425             // frame.
 426             qp_delta = -1;
 427         } else {
 428             // The HRD buffer fullness is increasing, so do nothing.  (We may be under the target
 429             // level here, but are moving in the right direction.)
 430             qp_delta = 0;
 431         }
 432     } else {
 433         // The frame is larger than the average size expected for this frame type.
 434         if (mfc_context->hrd.current_buffer_fullness[0] > mfc_context->hrd.target_buffer_fullness[0]) {
 435             // We are currently over the target level, so do nothing.
 436             qp_delta = 0;
 437         } else if (mfc_context->hrd.current_buffer_fullness[0] > mfc_context->hrd.target_buffer_fullness[0] / 2.0) {
 438             // We are under the target level, but not critically.  Increase the QP by one step if
 439             // continuing like this would underflow soon (currently within one second).
 440             if (mfc_context->hrd.current_buffer_fullness[0] /
 441                 (double)(frame_bits - mfc_context->brc.target_frame_size[0][slice_type] + 1) <
 442                 ((double)encoder_context->brc.framerate[0].num / (double)encoder_context->brc.framerate[0].den))
 443                 qp_delta = +1;
 444             else
 445                 qp_delta = 0;
 446         } else {
 447             // We are a long way under the target level.  Always increase the QP, possibly by a
 448             // larger amount dependent on how big the frame we just made actually was.
 449             qp_delta = +1 + large_frame_adjustment;
 450         }
 451     }
 452
 453     switch (slice_type) {
 454     case SLICE_TYPE_I:
 455         qp[SLICE_TYPE_I] += qp_delta;
 456         qp[SLICE_TYPE_P]  = qp[SLICE_TYPE_I] + BRC_I_P_QP_DIFF;
 457         qp[SLICE_TYPE_B]  = qp[SLICE_TYPE_I] + BRC_I_B_QP_DIFF;
 458         break;
 459     case SLICE_TYPE_P:
 460         qp[SLICE_TYPE_P] += qp_delta;
 461         qp[SLICE_TYPE_I]  = qp[SLICE_TYPE_P] - BRC_I_P_QP_DIFF;
 462         qp[SLICE_TYPE_B]  = qp[SLICE_TYPE_P] + BRC_P_B_QP_DIFF;
 463         break;
 464     case SLICE_TYPE_B:
 465         qp[SLICE_TYPE_B] += qp_delta;
 466         qp[SLICE_TYPE_I]  = qp[SLICE_TYPE_B] - BRC_I_B_QP_DIFF;
 467         qp[SLICE_TYPE_P]  = qp[SLICE_TYPE_B] - BRC_P_B_QP_DIFF;
 468         break;
 469     }
 470     BRC_CLIP(mfc_context->brc.qp_prime_y[0][SLICE_TYPE_I], min_qp, 51);
 471     BRC_CLIP(mfc_context->brc.qp_prime_y[0][SLICE_TYPE_P], min_qp, 51);
 472     BRC_CLIP(mfc_context->brc.qp_prime_y[0][SLICE_TYPE_B], min_qp, 51);
 473
 474     if (sts == BRC_UNDERFLOW && qp[slice_type] == 51)
 475         sts = BRC_UNDERFLOW_WITH_MAX_QP;
 476     if (sts == BRC_OVERFLOW && qp[slice_type] == min_qp)
 477         sts = BRC_OVERFLOW_WITH_MIN_QP;
 478
 479     return sts;
 480 }
 481
 482 int intel_mfc_brc_postpack(struct encode_state *encode_state,
 483                            struct intel_encoder_context *encoder_context,
 484                            int frame_bits)
 485 {
 486     switch (encoder_context->rate_control_mode) {
 487     case VA_RC_CBR:
 488         return intel_mfc_brc_postpack_cbr(encode_state, encoder_context, frame_bits);
 489     case VA_RC_VBR:
 490         return intel_mfc_brc_postpack_vbr(encode_state, encoder_context, frame_bits);
 491     }
 492     assert(0 && "Invalid RC mode");
 493     return 1;
 494 }
 495
 496 static void intel_mfc_hrd_context_init(struct encode_state *encode_state,
 497                                        struct intel_encoder_context *encoder_context)
 498 {
 499     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 500     unsigned int rate_control_mode = encoder_context->rate_control_mode;
 501     int target_bit_rate = encoder_context->brc.bits_per_second[encoder_context->layer.num_layers - 1];
 502
 503     // current we only support CBR mode.
 504     if (rate_control_mode == VA_RC_CBR) {
 505         mfc_context->vui_hrd.i_bit_rate_value = target_bit_rate >> 10;
 506         mfc_context->vui_hrd.i_initial_cpb_removal_delay = ((target_bit_rate * 8) >> 10) * 0.5 * 1024 / target_bit_rate * 90000;
 507         mfc_context->vui_hrd.i_cpb_removal_delay = 2;
 508         mfc_context->vui_hrd.i_frame_number = 0;
 509
 510         mfc_context->vui_hrd.i_initial_cpb_removal_delay_length = 24;
 511         mfc_context->vui_hrd.i_cpb_removal_delay_length = 24;
 512         mfc_context->vui_hrd.i_dpb_output_delay_length = 24;
 513     }
 514
 515 }
 516
 517 void
 518 intel_mfc_hrd_context_update(struct encode_state *encode_state,
 519                              struct gen6_mfc_context *mfc_context)
 520 {
 521     mfc_context->vui_hrd.i_frame_number++;
 522 }
 523
 524 int intel_mfc_interlace_check(VADriverContextP ctx,
 525                               struct encode_state *encode_state,
 526                               struct intel_encoder_context *encoder_context)
 527 {
 528     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 529     VAEncSliceParameterBufferH264 *pSliceParameter;
 530     int i;
 531     int mbCount = 0;
 532     int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
 533     int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
 534
 535     for (i = 0; i < encode_state->num_slice_params_ext; i++) {
 536         pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[i]->buffer;
 537         mbCount += pSliceParameter->num_macroblocks;
 538     }
 539
 540     if (mbCount == (width_in_mbs * height_in_mbs))
 541         return 0;
 542
 543     return 1;
 544 }
 545
 546 void intel_mfc_brc_prepare(struct encode_state *encode_state,
 547                            struct intel_encoder_context *encoder_context)
 548 {
 549     unsigned int rate_control_mode = encoder_context->rate_control_mode;
 550
 551     if (encoder_context->codec != CODEC_H264 &&
 552         encoder_context->codec != CODEC_H264_MVC)
 553         return;
 554
 555     if (rate_control_mode != VA_RC_CQP) {
 556         /*Programing bit rate control */
 557         if (encoder_context->brc.need_reset) {
 558             intel_mfc_bit_rate_control_context_init(encode_state, encoder_context);
 559             intel_mfc_brc_init(encode_state, encoder_context);
 560         }
 561
 562         /*Programing HRD control */
 563         if (encoder_context->brc.need_reset)
 564             intel_mfc_hrd_context_init(encode_state, encoder_context);
 565     }
 566 }
 567
 568 void intel_mfc_avc_pipeline_header_programing(VADriverContextP ctx,
 569                                               struct encode_state *encode_state,
 570                                               struct intel_encoder_context *encoder_context,
 571                                               struct intel_batchbuffer *slice_batch)
 572 {
 573     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 574     int idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_SPS);
 575     unsigned int skip_emul_byte_cnt;
 576
 577     if (encode_state->packed_header_data[idx]) {
 578         VAEncPackedHeaderParameterBuffer *param = NULL;
 579         unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
 580         unsigned int length_in_bits;
 581
 582         assert(encode_state->packed_header_param[idx]);
 583         param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
 584         length_in_bits = param->bit_length;
 585
 586         skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
 587         mfc_context->insert_object(ctx,
 588                                    encoder_context,
 589                                    header_data,
 590                                    ALIGN(length_in_bits, 32) >> 5,
 591                                    length_in_bits & 0x1f,
 592                                    skip_emul_byte_cnt,
 593                                    0,
 594                                    0,
 595                                    !param->has_emulation_bytes,
 596                                    slice_batch);
 597     }
 598
 599     idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_PPS);
 600
 601     if (encode_state->packed_header_data[idx]) {
 602         VAEncPackedHeaderParameterBuffer *param = NULL;
 603         unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
 604         unsigned int length_in_bits;
 605
 606         assert(encode_state->packed_header_param[idx]);
 607         param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
 608         length_in_bits = param->bit_length;
 609
 610         skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
 611
 612         mfc_context->insert_object(ctx,
 613                                    encoder_context,
 614                                    header_data,
 615                                    ALIGN(length_in_bits, 32) >> 5,
 616                                    length_in_bits & 0x1f,
 617                                    skip_emul_byte_cnt,
 618                                    0,
 619                                    0,
 620                                    !param->has_emulation_bytes,
 621                                    slice_batch);
 622     }
 623
 624     idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_SEI);
 625
 626     if (encode_state->packed_header_data[idx]) {
 627         VAEncPackedHeaderParameterBuffer *param = NULL;
 628         unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
 629         unsigned int length_in_bits;
 630
 631         assert(encode_state->packed_header_param[idx]);
 632         param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
 633         length_in_bits = param->bit_length;
 634
 635         skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
 636         mfc_context->insert_object(ctx,
 637                                    encoder_context,
 638                                    header_data,
 639                                    ALIGN(length_in_bits, 32) >> 5,
 640                                    length_in_bits & 0x1f,
 641                                    skip_emul_byte_cnt,
 642                                    0,
 643                                    0,
 644                                    !param->has_emulation_bytes,
 645                                    slice_batch);
 646     }
 647 }
 648
 649 VAStatus intel_mfc_avc_prepare(VADriverContextP ctx,
 650                                struct encode_state *encode_state,
 651                                struct intel_encoder_context *encoder_context)
 652 {
 653     struct i965_driver_data *i965 = i965_driver_data(ctx);
 654     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 655     struct object_surface *obj_surface;
 656     struct object_buffer *obj_buffer;
 657     GenAvcSurface *gen6_avc_surface;
 658     dri_bo *bo;
 659     VAStatus vaStatus = VA_STATUS_SUCCESS;
 660     int i, j, enable_avc_ildb = 0;
 661     VAEncSliceParameterBufferH264 *slice_param;
 662     struct i965_coded_buffer_segment *coded_buffer_segment;
 663     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
 664     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
 665     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
 666
 667     if (IS_GEN6(i965->intel.device_info)) {
 668         /* On the SNB it should be fixed to 128 for the DMV buffer */
 669         width_in_mbs = 128;
 670     }
 671
 672     for (j = 0; j < encode_state->num_slice_params_ext && enable_avc_ildb == 0; j++) {
 673         assert(encode_state->slice_params_ext && encode_state->slice_params_ext[j]->buffer);
 674         slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[j]->buffer;
 675
 676         for (i = 0; i < encode_state->slice_params_ext[j]->num_elements; i++) {
 677             assert((slice_param->slice_type == SLICE_TYPE_I) ||
 678                    (slice_param->slice_type == SLICE_TYPE_SI) ||
 679                    (slice_param->slice_type == SLICE_TYPE_P) ||
 680                    (slice_param->slice_type == SLICE_TYPE_SP) ||
 681                    (slice_param->slice_type == SLICE_TYPE_B));
 682
 683             if (slice_param->disable_deblocking_filter_idc != 1) {
 684                 enable_avc_ildb = 1;
 685                 break;
 686             }
 687
 688             slice_param++;
 689         }
 690     }
 691
 692     /*Setup all the input&output object*/
 693
 694     /* Setup current frame and current direct mv buffer*/
 695     obj_surface = encode_state->reconstructed_object;
 696     i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
 697
 698     if (obj_surface->private_data == NULL) {
 699         gen6_avc_surface = calloc(sizeof(GenAvcSurface), 1);
 700         assert(gen6_avc_surface);
 701         gen6_avc_surface->dmv_top =
 702             dri_bo_alloc(i965->intel.bufmgr,
 703                          "Buffer",
 704                          68 * width_in_mbs * height_in_mbs,
 705                          64);
 706         gen6_avc_surface->dmv_bottom =
 707             dri_bo_alloc(i965->intel.bufmgr,
 708                          "Buffer",
 709                          68 * width_in_mbs * height_in_mbs,
 710                          64);
 711         assert(gen6_avc_surface->dmv_top);
 712         assert(gen6_avc_surface->dmv_bottom);
 713         obj_surface->private_data = (void *)gen6_avc_surface;
 714         obj_surface->free_private_data = (void *)gen_free_avc_surface;
 715     }
 716     gen6_avc_surface = (GenAvcSurface *) obj_surface->private_data;
 717     mfc_context->direct_mv_buffers[NUM_MFC_DMV_BUFFERS - 2].bo = gen6_avc_surface->dmv_top;
 718     mfc_context->direct_mv_buffers[NUM_MFC_DMV_BUFFERS - 1].bo = gen6_avc_surface->dmv_bottom;
 719     dri_bo_reference(gen6_avc_surface->dmv_top);
 720     dri_bo_reference(gen6_avc_surface->dmv_bottom);
 721
 722     if (enable_avc_ildb) {
 723         mfc_context->post_deblocking_output.bo = obj_surface->bo;
 724         dri_bo_reference(mfc_context->post_deblocking_output.bo);
 725     } else {
 726         mfc_context->pre_deblocking_output.bo = obj_surface->bo;
 727         dri_bo_reference(mfc_context->pre_deblocking_output.bo);
 728     }
 729
 730     mfc_context->surface_state.width = obj_surface->orig_width;
 731     mfc_context->surface_state.height = obj_surface->orig_height;
 732     mfc_context->surface_state.w_pitch = obj_surface->width;
 733     mfc_context->surface_state.h_pitch = obj_surface->height;
 734
 735     /* Setup reference frames and direct mv buffers*/
 736     for (i = 0; i < MAX_MFC_REFERENCE_SURFACES; i++) {
 737         obj_surface = encode_state->reference_objects[i];
 738
 739         if (obj_surface && obj_surface->bo) {
 740             mfc_context->reference_surfaces[i].bo = obj_surface->bo;
 741             dri_bo_reference(obj_surface->bo);
 742
 743             /* Check DMV buffer */
 744             if (obj_surface->private_data == NULL) {
 745
 746                 gen6_avc_surface = calloc(sizeof(GenAvcSurface), 1);
 747                 assert(gen6_avc_surface);
 748                 gen6_avc_surface->dmv_top =
 749                     dri_bo_alloc(i965->intel.bufmgr,
 750                                  "Buffer",
 751                                  68 * width_in_mbs * height_in_mbs,
 752                                  64);
 753                 gen6_avc_surface->dmv_bottom =
 754                     dri_bo_alloc(i965->intel.bufmgr,
 755                                  "Buffer",
 756                                  68 * width_in_mbs * height_in_mbs,
 757                                  64);
 758                 assert(gen6_avc_surface->dmv_top);
 759                 assert(gen6_avc_surface->dmv_bottom);
 760                 obj_surface->private_data = gen6_avc_surface;
 761                 obj_surface->free_private_data = gen_free_avc_surface;
 762             }
 763
 764             gen6_avc_surface = (GenAvcSurface *) obj_surface->private_data;
 765             /* Setup DMV buffer */
 766             mfc_context->direct_mv_buffers[i * 2].bo = gen6_avc_surface->dmv_top;
 767             mfc_context->direct_mv_buffers[i * 2 + 1].bo = gen6_avc_surface->dmv_bottom;
 768             dri_bo_reference(gen6_avc_surface->dmv_top);
 769             dri_bo_reference(gen6_avc_surface->dmv_bottom);
 770         } else {
 771             break;
 772         }
 773     }
 774
 775     mfc_context->uncompressed_picture_source.bo = encode_state->input_yuv_object->bo;
 776     dri_bo_reference(mfc_context->uncompressed_picture_source.bo);
 777
 778     obj_buffer = encode_state->coded_buf_object;
 779     bo = obj_buffer->buffer_store->bo;
 780     mfc_context->mfc_indirect_pak_bse_object.bo = bo;
 781     mfc_context->mfc_indirect_pak_bse_object.offset = I965_CODEDBUFFER_HEADER_SIZE;
 782     mfc_context->mfc_indirect_pak_bse_object.end_offset = ALIGN(obj_buffer->size_element - 0x1000, 0x1000);
 783     dri_bo_reference(mfc_context->mfc_indirect_pak_bse_object.bo);
 784
 785     dri_bo_map(bo, 1);
 786     coded_buffer_segment = (struct i965_coded_buffer_segment *)bo->virtual;
 787     coded_buffer_segment->mapped = 0;
 788     coded_buffer_segment->codec = encoder_context->codec;
 789     dri_bo_unmap(bo);
 790
 791     return vaStatus;
 792 }
 793 /*
 794  * The LUT uses the pair of 4-bit units: (shift, base) structure.
 795  * 2^K * X = value .
 796  * So it is necessary to convert one cost into the nearest LUT format.
 797  * The derivation is:
 798  * 2^K *x = 2^n * (1 + deltaX)
 799  *    k + log2(x) = n + log2(1 + deltaX)
 800  *    log2(x) = n - k + log2(1 + deltaX)
 801  *    As X is in the range of [1, 15]
 802  *      4 > n - k + log2(1 + deltaX) >= 0
 803  *      =>    n + log2(1 + deltaX)  >= k > n - 4  + log2(1 + deltaX)
 804  *    Then we can derive the corresponding K and get the nearest LUT format.
 805  */
 806 int intel_format_lutvalue(int value, int max)
 807 {
 808     int ret;
 809     int logvalue, temp1, temp2;
 810
 811     if (value <= 0)
 812         return 0;
 813
 814     logvalue = (int)(log2f((float)value));
 815     if (logvalue < 4) {
 816         ret = value;
 817     } else {
 818         int error, temp_value, base, j, temp_err;
 819         error = value;
 820         j = logvalue - 4 + 1;
 821         ret = -1;
 822         for (; j <= logvalue; j++) {
 823             if (j == 0) {
 824                 base = value >> j;
 825             } else {
 826                 base = (value + (1 << (j - 1)) - 1) >> j;
 827             }
 828             if (base >= 16)
 829                 continue;
 830
 831             temp_value = base << j;
 832             temp_err = abs(value - temp_value);
 833             if (temp_err < error) {
 834                 error = temp_err;
 835                 ret = (j << 4) | base;
 836                 if (temp_err == 0)
 837                     break;
 838             }
 839         }
 840     }
 841     temp1 = (ret & 0xf) << ((ret & 0xf0) >> 4);
 842     temp2 = (max & 0xf) << ((max & 0xf0) >> 4);
 843     if (temp1 > temp2)
 844         ret = max;
 845     return ret;
 846
 847 }
 848
 849
 850 #define     QP_MAX          52
 851 #define     VP8_QP_MAX          128
 852
 853
 854 static float intel_lambda_qp(int qp)
 855 {
 856     float value, lambdaf;
 857     value = qp;
 858     value = value / 6 - 2;
 859     if (value < 0)
 860         value = 0;
 861     lambdaf = roundf(powf(2, value));
 862     return lambdaf;
 863 }
 864
 865 static
 866 void intel_h264_calc_mbmvcost_qp(int qp,
 867                                  int slice_type,
 868                                  uint8_t *vme_state_message)
 869 {
 870     int m_cost, j, mv_count;
 871     float   lambda, m_costf;
 872
 873     assert(qp <= QP_MAX);
 874     lambda = intel_lambda_qp(qp);
 875
 876     m_cost = lambda;
 877     vme_state_message[MODE_CHROMA_INTRA] = 0;
 878     vme_state_message[MODE_REFID_COST] = intel_format_lutvalue(m_cost, 0x8f);
 879
 880     if (slice_type == SLICE_TYPE_I) {
 881         vme_state_message[MODE_INTRA_16X16] = 0;
 882         m_cost = lambda * 4;
 883         vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
 884         m_cost = lambda * 16;
 885         vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
 886         m_cost = lambda * 3;
 887         vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
 888     } else {
 889         m_cost = 0;
 890         vme_state_message[MODE_INTER_MV0] = intel_format_lutvalue(m_cost, 0x6f);
 891         for (j = 1; j < 3; j++) {
 892             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
 893             m_cost = (int)m_costf;
 894             vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
 895         }
 896         mv_count = 3;
 897         for (j = 4; j <= 64; j *= 2) {
 898             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
 899             m_cost = (int)m_costf;
 900             vme_state_message[MODE_INTER_MV0 + mv_count] = intel_format_lutvalue(m_cost, 0x6f);
 901             mv_count++;
 902         }
 903
 904         if (qp <= 25) {
 905             vme_state_message[MODE_INTRA_16X16] = 0x4a;
 906             vme_state_message[MODE_INTRA_8X8] = 0x4a;
 907             vme_state_message[MODE_INTRA_4X4] = 0x4a;
 908             vme_state_message[MODE_INTRA_NONPRED] = 0x4a;
 909             vme_state_message[MODE_INTER_16X16] = 0x4a;
 910             vme_state_message[MODE_INTER_16X8] = 0x4a;
 911             vme_state_message[MODE_INTER_8X8] = 0x4a;
 912             vme_state_message[MODE_INTER_8X4] = 0x4a;
 913             vme_state_message[MODE_INTER_4X4] = 0x4a;
 914             vme_state_message[MODE_INTER_BWD] = 0x2a;
 915             return;
 916         }
 917         m_costf = lambda * 10;
 918         vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
 919         m_cost = lambda * 14;
 920         vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
 921         m_cost = lambda * 24;
 922         vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
 923         m_costf = lambda * 3.5;
 924         m_cost = m_costf;
 925         vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
 926         if (slice_type == SLICE_TYPE_P) {
 927             m_costf = lambda * 2.5;
 928             m_cost = m_costf;
 929             vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
 930             m_costf = lambda * 4;
 931             m_cost = m_costf;
 932             vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
 933             m_costf = lambda * 1.5;
 934             m_cost = m_costf;
 935             vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
 936             m_costf = lambda * 3;
 937             m_cost = m_costf;
 938             vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
 939             m_costf = lambda * 5;
 940             m_cost = m_costf;
 941             vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
 942             /* BWD is not used in P-frame */
 943             vme_state_message[MODE_INTER_BWD] = 0;
 944         } else {
 945             m_costf = lambda * 2.5;
 946             m_cost = m_costf;
 947             vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
 948             m_costf = lambda * 5.5;
 949             m_cost = m_costf;
 950             vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
 951             m_costf = lambda * 3.5;
 952             m_cost = m_costf;
 953             vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
 954             m_costf = lambda * 5.0;
 955             m_cost = m_costf;
 956             vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
 957             m_costf = lambda * 6.5;
 958             m_cost = m_costf;
 959             vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
 960             m_costf = lambda * 1.5;
 961             m_cost = m_costf;
 962             vme_state_message[MODE_INTER_BWD] = intel_format_lutvalue(m_cost, 0x6f);
 963         }
 964     }
 965     return;
 966 }
 967
 968 void intel_vme_update_mbmv_cost(VADriverContextP ctx,
 969                                 struct encode_state *encode_state,
 970                                 struct intel_encoder_context *encoder_context)
 971 {
 972     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 973     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 974     VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
 975     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
 976     int qp;
 977     uint8_t *vme_state_message = (uint8_t *)(vme_context->vme_state_message);
 978
 979     int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
 980
 981     if (encoder_context->rate_control_mode == VA_RC_CQP)
 982         qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
 983     else
 984         qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
 985
 986     if (vme_state_message == NULL)
 987         return;
 988
 989     intel_h264_calc_mbmvcost_qp(qp, slice_type, vme_state_message);
 990 }
 991
 992 void intel_vme_vp8_update_mbmv_cost(VADriverContextP ctx,
 993                                     struct encode_state *encode_state,
 994                                     struct intel_encoder_context *encoder_context)
 995 {
 996     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
 997     struct gen6_vme_context *vme_context = encoder_context->vme_context;
 998     VAEncPictureParameterBufferVP8 *pic_param = (VAEncPictureParameterBufferVP8 *)encode_state->pic_param_ext->buffer;
 999     VAQMatrixBufferVP8 *q_matrix = (VAQMatrixBufferVP8 *)encode_state->q_matrix->buffer;
1000     int qp, m_cost, j, mv_count;
1001     uint8_t *vme_state_message = (uint8_t *)(vme_context->vme_state_message);
1002     float   lambda, m_costf;
1003
1004     int is_key_frame = !pic_param->pic_flags.bits.frame_type;
1005     int slice_type = (is_key_frame ? SLICE_TYPE_I : SLICE_TYPE_P);
1006
1007     if (vme_state_message == NULL)
1008         return;
1009
1010     if (encoder_context->rate_control_mode == VA_RC_CQP)
1011         qp = q_matrix->quantization_index[0];
1012     else
1013         qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
1014
1015     lambda = intel_lambda_qp(qp * QP_MAX / VP8_QP_MAX);
1016
1017     m_cost = lambda;
1018     vme_state_message[MODE_CHROMA_INTRA] = intel_format_lutvalue(m_cost, 0x8f);
1019
1020     if (is_key_frame) {
1021         vme_state_message[MODE_INTRA_16X16] = 0;
1022         m_cost = lambda * 16;
1023         vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
1024         m_cost = lambda * 3;
1025         vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
1026     } else {
1027         m_cost = 0;
1028         vme_state_message[MODE_INTER_MV0] = intel_format_lutvalue(m_cost, 0x6f);
1029         for (j = 1; j < 3; j++) {
1030             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1031             m_cost = (int)m_costf;
1032             vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
1033         }
1034         mv_count = 3;
1035         for (j = 4; j <= 64; j *= 2) {
1036             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1037             m_cost = (int)m_costf;
1038             vme_state_message[MODE_INTER_MV0 + mv_count] = intel_format_lutvalue(m_cost, 0x6f);
1039             mv_count++;
1040         }
1041
1042         if (qp < 92) {
1043             vme_state_message[MODE_INTRA_16X16] = 0x4a;
1044             vme_state_message[MODE_INTRA_4X4] = 0x4a;
1045             vme_state_message[MODE_INTRA_NONPRED] = 0x4a;
1046             vme_state_message[MODE_INTER_16X16] = 0x4a;
1047             vme_state_message[MODE_INTER_16X8] = 0x4a;
1048             vme_state_message[MODE_INTER_8X8] = 0x4a;
1049             vme_state_message[MODE_INTER_4X4] = 0x4a;
1050             vme_state_message[MODE_INTER_BWD] = 0;
1051             return;
1052         }
1053         m_costf = lambda * 10;
1054         vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1055         m_cost = lambda * 24;
1056         vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
1057
1058         m_costf = lambda * 3.5;
1059         m_cost = m_costf;
1060         vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
1061
1062         m_costf = lambda * 2.5;
1063         m_cost = m_costf;
1064         vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1065         m_costf = lambda * 4;
1066         m_cost = m_costf;
1067         vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
1068         m_costf = lambda * 1.5;
1069         m_cost = m_costf;
1070         vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
1071         m_costf = lambda * 5;
1072         m_cost = m_costf;
1073         vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
1074         /* BWD is not used in P-frame */
1075         vme_state_message[MODE_INTER_BWD] = 0;
1076     }
1077 }
1078
1079 #define     MB_SCOREBOARD_A     (1 << 0)
1080 #define     MB_SCOREBOARD_B     (1 << 1)
1081 #define     MB_SCOREBOARD_C     (1 << 2)
1082 void
1083 gen7_vme_scoreboard_init(VADriverContextP ctx, struct gen6_vme_context *vme_context)
1084 {
1085     vme_context->gpe_context.vfe_desc5.scoreboard0.enable = 1;
1086     vme_context->gpe_context.vfe_desc5.scoreboard0.type = SCOREBOARD_STALLING;
1087     vme_context->gpe_context.vfe_desc5.scoreboard0.mask = (MB_SCOREBOARD_A |
1088                                                            MB_SCOREBOARD_B |
1089                                                            MB_SCOREBOARD_C);
1090
1091     /* In VME prediction the current mb depends on the neighbour
1092      * A/B/C macroblock. So the left/up/up-right dependency should
1093      * be considered.
1094      */
1095     vme_context->gpe_context.vfe_desc6.scoreboard1.delta_x0 = -1;
1096     vme_context->gpe_context.vfe_desc6.scoreboard1.delta_y0 = 0;
1097     vme_context->gpe_context.vfe_desc6.scoreboard1.delta_x1 = 0;
1098     vme_context->gpe_context.vfe_desc6.scoreboard1.delta_y1 = -1;
1099     vme_context->gpe_context.vfe_desc6.scoreboard1.delta_x2 = 1;
1100     vme_context->gpe_context.vfe_desc6.scoreboard1.delta_y2 = -1;
1101
1102     vme_context->gpe_context.vfe_desc7.dword = 0;
1103     return;
1104 }
1105
1106 /* check whether the mb of (x_index, y_index) is out of bound */
1107 static inline int loop_in_bounds(int x_index, int y_index, int first_mb, int num_mb, int mb_width, int mb_height)
1108 {
1109     int mb_index;
1110     if (x_index < 0 || x_index >= mb_width)
1111         return -1;
1112     if (y_index < 0 || y_index >= mb_height)
1113         return -1;
1114
1115     mb_index = y_index * mb_width + x_index;
1116     if (mb_index < first_mb || mb_index > (first_mb + num_mb))
1117         return -1;
1118     return 0;
1119 }
1120
1121 void
1122 gen7_vme_walker_fill_vme_batchbuffer(VADriverContextP ctx,
1123                                      struct encode_state *encode_state,
1124                                      int mb_width, int mb_height,
1125                                      int kernel,
1126                                      int transform_8x8_mode_flag,
1127                                      struct intel_encoder_context *encoder_context)
1128 {
1129     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1130     int mb_row;
1131     int s;
1132     unsigned int *command_ptr;
1133     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1134     VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1135     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1136     int qp, qp_mb, qp_index;
1137     int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1138
1139     if (encoder_context->rate_control_mode == VA_RC_CQP)
1140         qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
1141     else
1142         qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
1143
1144 #define     USE_SCOREBOARD      (1 << 21)
1145
1146     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
1147     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
1148
1149     for (s = 0; s < encode_state->num_slice_params_ext; s++) {
1150         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[s]->buffer;
1151         int first_mb = pSliceParameter->macroblock_address;
1152         int num_mb = pSliceParameter->num_macroblocks;
1153         unsigned int mb_intra_ub, score_dep;
1154         int x_outer, y_outer, x_inner, y_inner;
1155         int xtemp_outer = 0;
1156
1157         x_outer = first_mb % mb_width;
1158         y_outer = first_mb / mb_width;
1159         mb_row = y_outer;
1160
1161         for (; x_outer < (mb_width - 2) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1162             x_inner = x_outer;
1163             y_inner = y_outer;
1164             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1165                 mb_intra_ub = 0;
1166                 score_dep = 0;
1167                 if (x_inner != 0) {
1168                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1169                     score_dep |= MB_SCOREBOARD_A;
1170                 }
1171                 if (y_inner != mb_row) {
1172                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1173                     score_dep |= MB_SCOREBOARD_B;
1174                     if (x_inner != 0)
1175                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1176                     if (x_inner != (mb_width - 1)) {
1177                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1178                         score_dep |= MB_SCOREBOARD_C;
1179                     }
1180                 }
1181
1182                 *command_ptr++ = (CMD_MEDIA_OBJECT | (9 - 2));
1183                 *command_ptr++ = kernel;
1184                 *command_ptr++ = USE_SCOREBOARD;
1185                 /* Indirect data */
1186                 *command_ptr++ = 0;
1187                 /* the (X, Y) term of scoreboard */
1188                 *command_ptr++ = ((y_inner << 16) | x_inner);
1189                 *command_ptr++ = score_dep;
1190                 /*inline data */
1191                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1192                 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
1193                 /* QP occupies one byte */
1194                 if (vme_context->roi_enabled) {
1195                     qp_index = y_inner * mb_width + x_inner;
1196                     qp_mb = *(vme_context->qp_per_mb + qp_index);
1197                 } else
1198                     qp_mb = qp;
1199                 *command_ptr++ = qp_mb;
1200                 x_inner -= 2;
1201                 y_inner += 1;
1202             }
1203             x_outer += 1;
1204         }
1205
1206         xtemp_outer = mb_width - 2;
1207         if (xtemp_outer < 0)
1208             xtemp_outer = 0;
1209         x_outer = xtemp_outer;
1210         y_outer = first_mb / mb_width;
1211         for (; !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1212             y_inner = y_outer;
1213             x_inner = x_outer;
1214             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1215                 mb_intra_ub = 0;
1216                 score_dep = 0;
1217                 if (x_inner != 0) {
1218                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1219                     score_dep |= MB_SCOREBOARD_A;
1220                 }
1221                 if (y_inner != mb_row) {
1222                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1223                     score_dep |= MB_SCOREBOARD_B;
1224                     if (x_inner != 0)
1225                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1226
1227                     if (x_inner != (mb_width - 1)) {
1228                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1229                         score_dep |= MB_SCOREBOARD_C;
1230                     }
1231                 }
1232
1233                 *command_ptr++ = (CMD_MEDIA_OBJECT | (9 - 2));
1234                 *command_ptr++ = kernel;
1235                 *command_ptr++ = USE_SCOREBOARD;
1236                 /* Indirect data */
1237                 *command_ptr++ = 0;
1238                 /* the (X, Y) term of scoreboard */
1239                 *command_ptr++ = ((y_inner << 16) | x_inner);
1240                 *command_ptr++ = score_dep;
1241                 /*inline data */
1242                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1243                 *command_ptr++ = ((1 << 18) | (1 << 16) | transform_8x8_mode_flag | (mb_intra_ub << 8));
1244                 /* qp occupies one byte */
1245                 if (vme_context->roi_enabled) {
1246                     qp_index = y_inner * mb_width + x_inner;
1247                     qp_mb = *(vme_context->qp_per_mb + qp_index);
1248                 } else
1249                     qp_mb = qp;
1250                 *command_ptr++ = qp_mb;
1251
1252                 x_inner -= 2;
1253                 y_inner += 1;
1254             }
1255             x_outer++;
1256             if (x_outer >= mb_width) {
1257                 y_outer += 1;
1258                 x_outer = xtemp_outer;
1259             }
1260         }
1261     }
1262
1263     *command_ptr++ = 0;
1264     *command_ptr++ = MI_BATCH_BUFFER_END;
1265
1266     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
1267 }
1268
1269 static uint8_t
1270 intel_get_ref_idx_state_1(VAPictureH264 *va_pic, unsigned int frame_store_id)
1271 {
1272     unsigned int is_long_term =
1273         !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);
1274     unsigned int is_top_field =
1275         !!(va_pic->flags & VA_PICTURE_H264_TOP_FIELD);
1276     unsigned int is_bottom_field =
1277         !!(va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD);
1278
1279     return ((is_long_term                         << 6) |
1280             ((is_top_field ^ is_bottom_field ^ 1) << 5) |
1281             (frame_store_id                       << 1) |
1282             ((is_top_field ^ 1) & is_bottom_field));
1283 }
1284
1285 void
1286 intel_mfc_avc_ref_idx_state(VADriverContextP ctx,
1287                             struct encode_state *encode_state,
1288                             struct intel_encoder_context *encoder_context)
1289 {
1290     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1291     struct intel_batchbuffer *batch = encoder_context->base.batch;
1292     int slice_type;
1293     struct object_surface *obj_surface;
1294     unsigned int fref_entry, bref_entry;
1295     int frame_index, i;
1296     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1297
1298     fref_entry = 0x80808080;
1299     bref_entry = 0x80808080;
1300     slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1301
1302     if (slice_type == SLICE_TYPE_P || slice_type == SLICE_TYPE_B) {
1303         int ref_idx_l0 = (vme_context->ref_index_in_mb[0] & 0xff);
1304
1305         if (ref_idx_l0 > 3) {
1306             WARN_ONCE("ref_idx_l0 is out of range\n");
1307             ref_idx_l0 = 0;
1308         }
1309
1310         obj_surface = vme_context->used_reference_objects[0];
1311         frame_index = -1;
1312         for (i = 0; i < 16; i++) {
1313             if (obj_surface &&
1314                 obj_surface == encode_state->reference_objects[i]) {
1315                 frame_index = i;
1316                 break;
1317             }
1318         }
1319         if (frame_index == -1) {
1320             WARN_ONCE("RefPicList0 is not found in DPB!\n");
1321         } else {
1322             int ref_idx_l0_shift = ref_idx_l0 * 8;
1323             fref_entry &= ~(0xFF << ref_idx_l0_shift);
1324             fref_entry += (intel_get_ref_idx_state_1(vme_context->used_references[0], frame_index) << ref_idx_l0_shift);
1325         }
1326     }
1327
1328     if (slice_type == SLICE_TYPE_B) {
1329         int ref_idx_l1 = (vme_context->ref_index_in_mb[1] & 0xff);
1330
1331         if (ref_idx_l1 > 3) {
1332             WARN_ONCE("ref_idx_l1 is out of range\n");
1333             ref_idx_l1 = 0;
1334         }
1335
1336         obj_surface = vme_context->used_reference_objects[1];
1337         frame_index = -1;
1338         for (i = 0; i < 16; i++) {
1339             if (obj_surface &&
1340                 obj_surface == encode_state->reference_objects[i]) {
1341                 frame_index = i;
1342                 break;
1343             }
1344         }
1345         if (frame_index == -1) {
1346             WARN_ONCE("RefPicList1 is not found in DPB!\n");
1347         } else {
1348             int ref_idx_l1_shift = ref_idx_l1 * 8;
1349             bref_entry &= ~(0xFF << ref_idx_l1_shift);
1350             bref_entry += (intel_get_ref_idx_state_1(vme_context->used_references[1], frame_index) << ref_idx_l1_shift);
1351         }
1352     }
1353
1354     BEGIN_BCS_BATCH(batch, 10);
1355     OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | 8);
1356     OUT_BCS_BATCH(batch, 0);                  //Select L0
1357     OUT_BCS_BATCH(batch, fref_entry);         //Only 1 reference
1358     for (i = 0; i < 7; i++) {
1359         OUT_BCS_BATCH(batch, 0x80808080);
1360     }
1361     ADVANCE_BCS_BATCH(batch);
1362
1363     BEGIN_BCS_BATCH(batch, 10);
1364     OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | 8);
1365     OUT_BCS_BATCH(batch, 1);                  //Select L1
1366     OUT_BCS_BATCH(batch, bref_entry);         //Only 1 reference
1367     for (i = 0; i < 7; i++) {
1368         OUT_BCS_BATCH(batch, 0x80808080);
1369     }
1370     ADVANCE_BCS_BATCH(batch);
1371 }
1372
1373
1374 void intel_vme_mpeg2_state_setup(VADriverContextP ctx,
1375                                  struct encode_state *encode_state,
1376                                  struct intel_encoder_context *encoder_context)
1377 {
1378     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1379     uint32_t *vme_state_message = (uint32_t *)(vme_context->vme_state_message);
1380     VAEncSequenceParameterBufferMPEG2 *seq_param = (VAEncSequenceParameterBufferMPEG2 *)encode_state->seq_param_ext->buffer;
1381     int width_in_mbs = ALIGN(seq_param->picture_width, 16) / 16;
1382     int height_in_mbs = ALIGN(seq_param->picture_height, 16) / 16;
1383     uint32_t mv_x, mv_y;
1384     VAEncSliceParameterBufferMPEG2 *slice_param = NULL;
1385     VAEncPictureParameterBufferMPEG2 *pic_param = NULL;
1386     slice_param = (VAEncSliceParameterBufferMPEG2 *)encode_state->slice_params_ext[0]->buffer;
1387     pic_param = (VAEncPictureParameterBufferMPEG2 *)encode_state->pic_param_ext->buffer;
1388
1389     mv_x = 1 << (2 + pic_param->f_code[0][0]);
1390     mv_y = 1 << (2 + pic_param->f_code[0][1]);
1391
1392     if (pic_param->picture_type != VAEncPictureTypeIntra) {
1393         int qp, m_cost, j, mv_count;
1394         float   lambda, m_costf;
1395         slice_param = (VAEncSliceParameterBufferMPEG2 *)
1396                       encode_state->slice_params_ext[0]->buffer;
1397         qp = slice_param->quantiser_scale_code;
1398         lambda = intel_lambda_qp(qp);
1399         /* No Intra prediction. So it is zero */
1400         vme_state_message[MODE_INTRA_8X8] = 0;
1401         vme_state_message[MODE_INTRA_4X4] = 0;
1402         vme_state_message[MODE_INTER_MV0] = 0;
1403         for (j = 1; j < 3; j++) {
1404             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1405             m_cost = (int)m_costf;
1406             vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
1407         }
1408         mv_count = 3;
1409         for (j = 4; j <= 64; j *= 2) {
1410             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
1411             m_cost = (int)m_costf;
1412             vme_state_message[MODE_INTER_MV0 + mv_count] =
1413                 intel_format_lutvalue(m_cost, 0x6f);
1414             mv_count++;
1415         }
1416         m_cost = lambda;
1417         /* It can only perform the 16x16 search. So mode cost can be ignored for
1418          * the other mode. for example: 16x8/8x8
1419          */
1420         vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1421         vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
1422
1423         vme_state_message[MODE_INTER_16X8] = 0;
1424         vme_state_message[MODE_INTER_8X8] = 0;
1425         vme_state_message[MODE_INTER_8X4] = 0;
1426         vme_state_message[MODE_INTER_4X4] = 0;
1427         vme_state_message[MODE_INTER_BWD] = intel_format_lutvalue(m_cost, 0x6f);
1428
1429     }
1430     vme_state_message[MPEG2_MV_RANGE] = (mv_y << 16) | (mv_x);
1431
1432     vme_state_message[MPEG2_PIC_WIDTH_HEIGHT] = (height_in_mbs << 16) |
1433                                                 width_in_mbs;
1434 }
1435
1436 void
1437 gen7_vme_mpeg2_walker_fill_vme_batchbuffer(VADriverContextP ctx,
1438                                            struct encode_state *encode_state,
1439                                            int mb_width, int mb_height,
1440                                            int kernel,
1441                                            struct intel_encoder_context *encoder_context)
1442 {
1443     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1444     unsigned int *command_ptr;
1445
1446 #define     MPEG2_SCOREBOARD        (1 << 21)
1447
1448     dri_bo_map(vme_context->vme_batchbuffer.bo, 1);
1449     command_ptr = vme_context->vme_batchbuffer.bo->virtual;
1450
1451     {
1452         unsigned int mb_intra_ub, score_dep;
1453         int x_outer, y_outer, x_inner, y_inner;
1454         int xtemp_outer = 0;
1455         int first_mb = 0;
1456         int num_mb = mb_width * mb_height;
1457
1458         x_outer = 0;
1459         y_outer = 0;
1460
1461
1462         for (; x_outer < (mb_width - 2) && !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1463             x_inner = x_outer;
1464             y_inner = y_outer;
1465             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1466                 mb_intra_ub = 0;
1467                 score_dep = 0;
1468                 if (x_inner != 0) {
1469                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1470                     score_dep |= MB_SCOREBOARD_A;
1471                 }
1472                 if (y_inner != 0) {
1473                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1474                     score_dep |= MB_SCOREBOARD_B;
1475
1476                     if (x_inner != 0)
1477                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1478
1479                     if (x_inner != (mb_width - 1)) {
1480                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1481                         score_dep |= MB_SCOREBOARD_C;
1482                     }
1483                 }
1484
1485                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
1486                 *command_ptr++ = kernel;
1487                 *command_ptr++ = MPEG2_SCOREBOARD;
1488                 /* Indirect data */
1489                 *command_ptr++ = 0;
1490                 /* the (X, Y) term of scoreboard */
1491                 *command_ptr++ = ((y_inner << 16) | x_inner);
1492                 *command_ptr++ = score_dep;
1493                 /*inline data */
1494                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1495                 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
1496                 x_inner -= 2;
1497                 y_inner += 1;
1498             }
1499             x_outer += 1;
1500         }
1501
1502         xtemp_outer = mb_width - 2;
1503         if (xtemp_outer < 0)
1504             xtemp_outer = 0;
1505         x_outer = xtemp_outer;
1506         y_outer = 0;
1507         for (; !loop_in_bounds(x_outer, y_outer, first_mb, num_mb, mb_width, mb_height);) {
1508             y_inner = y_outer;
1509             x_inner = x_outer;
1510             for (; !loop_in_bounds(x_inner, y_inner, first_mb, num_mb, mb_width, mb_height);) {
1511                 mb_intra_ub = 0;
1512                 score_dep = 0;
1513                 if (x_inner != 0) {
1514                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_AE;
1515                     score_dep |= MB_SCOREBOARD_A;
1516                 }
1517                 if (y_inner != 0) {
1518                     mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_B;
1519                     score_dep |= MB_SCOREBOARD_B;
1520
1521                     if (x_inner != 0)
1522                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_D;
1523
1524                     if (x_inner != (mb_width - 1)) {
1525                         mb_intra_ub |= INTRA_PRED_AVAIL_FLAG_C;
1526                         score_dep |= MB_SCOREBOARD_C;
1527                     }
1528                 }
1529
1530                 *command_ptr++ = (CMD_MEDIA_OBJECT | (8 - 2));
1531                 *command_ptr++ = kernel;
1532                 *command_ptr++ = MPEG2_SCOREBOARD;
1533                 /* Indirect data */
1534                 *command_ptr++ = 0;
1535                 /* the (X, Y) term of scoreboard */
1536                 *command_ptr++ = ((y_inner << 16) | x_inner);
1537                 *command_ptr++ = score_dep;
1538                 /*inline data */
1539                 *command_ptr++ = (mb_width << 16 | y_inner << 8 | x_inner);
1540                 *command_ptr++ = ((1 << 18) | (1 << 16) | (mb_intra_ub << 8));
1541
1542                 x_inner -= 2;
1543                 y_inner += 1;
1544             }
1545             x_outer++;
1546             if (x_outer >= mb_width) {
1547                 y_outer += 1;
1548                 x_outer = xtemp_outer;
1549             }
1550         }
1551     }
1552
1553     *command_ptr++ = 0;
1554     *command_ptr++ = MI_BATCH_BUFFER_END;
1555
1556     dri_bo_unmap(vme_context->vme_batchbuffer.bo);
1557     return;
1558 }
1559
1560 static int
1561 avc_temporal_find_surface(VAPictureH264 *curr_pic,
1562                           VAPictureH264 *ref_list,
1563                           int num_pictures,
1564                           int dir)
1565 {
1566     int i, found = -1, min = 0x7FFFFFFF;
1567
1568     for (i = 0; i < num_pictures; i++) {
1569         int tmp;
1570
1571         if ((ref_list[i].flags & VA_PICTURE_H264_INVALID) ||
1572             (ref_list[i].picture_id == VA_INVALID_SURFACE))
1573             break;
1574
1575         tmp = curr_pic->TopFieldOrderCnt - ref_list[i].TopFieldOrderCnt;
1576
1577         if (dir)
1578             tmp = -tmp;
1579
1580         if (tmp > 0 && tmp < min) {
1581             min = tmp;
1582             found = i;
1583         }
1584     }
1585
1586     return found;
1587 }
1588
1589 void
1590 intel_avc_vme_reference_state(VADriverContextP ctx,
1591                               struct encode_state *encode_state,
1592                               struct intel_encoder_context *encoder_context,
1593                               int list_index,
1594                               int surface_index,
1595                               void (* vme_source_surface_state)(
1596                                   VADriverContextP ctx,
1597                                   int index,
1598                                   struct object_surface *obj_surface,
1599                                   struct intel_encoder_context *encoder_context))
1600 {
1601     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1602     struct object_surface *obj_surface = NULL;
1603     struct i965_driver_data *i965 = i965_driver_data(ctx);
1604     VASurfaceID ref_surface_id;
1605     VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1606     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1607     int max_num_references;
1608     VAPictureH264 *curr_pic;
1609     VAPictureH264 *ref_list;
1610     int ref_idx;
1611
1612     if (list_index == 0) {
1613         max_num_references = pic_param->num_ref_idx_l0_active_minus1 + 1;
1614         ref_list = slice_param->RefPicList0;
1615     } else {
1616         max_num_references = pic_param->num_ref_idx_l1_active_minus1 + 1;
1617         ref_list = slice_param->RefPicList1;
1618     }
1619
1620     if (max_num_references == 1) {
1621         if (list_index == 0) {
1622             ref_surface_id = slice_param->RefPicList0[0].picture_id;
1623             vme_context->used_references[0] = &slice_param->RefPicList0[0];
1624         } else {
1625             ref_surface_id = slice_param->RefPicList1[0].picture_id;
1626             vme_context->used_references[1] = &slice_param->RefPicList1[0];
1627         }
1628
1629         if (ref_surface_id != VA_INVALID_SURFACE)
1630             obj_surface = SURFACE(ref_surface_id);
1631
1632         if (!obj_surface ||
1633             !obj_surface->bo) {
1634             obj_surface = encode_state->reference_objects[list_index];
1635             vme_context->used_references[list_index] = &pic_param->ReferenceFrames[list_index];
1636         }
1637
1638         ref_idx = 0;
1639     } else {
1640         curr_pic = &pic_param->CurrPic;
1641
1642         /* select the reference frame in temporal space */
1643         ref_idx = avc_temporal_find_surface(curr_pic, ref_list, max_num_references, list_index == 1);
1644         ref_surface_id = ref_list[ref_idx].picture_id;
1645
1646         if (ref_surface_id != VA_INVALID_SURFACE) /* otherwise warning later */
1647             obj_surface = SURFACE(ref_surface_id);
1648
1649         vme_context->used_reference_objects[list_index] = obj_surface;
1650         vme_context->used_references[list_index] = &ref_list[ref_idx];
1651     }
1652
1653     if (obj_surface &&
1654         obj_surface->bo) {
1655         assert(ref_idx >= 0);
1656         vme_context->used_reference_objects[list_index] = obj_surface;
1657         vme_source_surface_state(ctx, surface_index, obj_surface, encoder_context);
1658         vme_context->ref_index_in_mb[list_index] = (ref_idx << 24 |
1659                                                     ref_idx << 16 |
1660                                                     ref_idx <<  8 |
1661                                                     ref_idx);
1662     } else {
1663         vme_context->used_reference_objects[list_index] = NULL;
1664         vme_context->used_references[list_index] = NULL;
1665         vme_context->ref_index_in_mb[list_index] = 0;
1666     }
1667 }
1668
1669 #define AVC_NAL_DELIMITER           9
1670 void
1671 intel_avc_insert_aud_packed_data(VADriverContextP ctx,
1672                                  struct encode_state *encode_state,
1673                                  struct intel_encoder_context *encoder_context,
1674                                  struct intel_batchbuffer *batch)
1675 {
1676     VAEncPackedHeaderParameterBuffer *param = NULL;
1677     unsigned int length_in_bits;
1678     unsigned int *header_data = NULL;
1679     unsigned char *nal_type = NULL;
1680     int count, i, start_index;
1681     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1682
1683     count = encode_state->slice_rawdata_count[0];
1684     start_index = (encode_state->slice_rawdata_index[0] & SLICE_PACKED_DATA_INDEX_MASK);
1685
1686     for (i = 0; i < count; i++) {
1687         unsigned int skip_emul_byte_cnt;
1688
1689         header_data = (unsigned int *)encode_state->packed_header_data_ext[start_index + i]->buffer;
1690         nal_type = (unsigned char *)header_data;
1691
1692         param = (VAEncPackedHeaderParameterBuffer *)(encode_state->packed_header_params_ext[start_index + i]->buffer);
1693
1694         length_in_bits = param->bit_length;
1695
1696         skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
1697
1698         if ((*(nal_type + skip_emul_byte_cnt - 1) & 0x1f) == AVC_NAL_DELIMITER) {
1699             mfc_context->insert_object(ctx,
1700                                        encoder_context,
1701                                        header_data,
1702                                        ALIGN(length_in_bits, 32) >> 5,
1703                                        length_in_bits & 0x1f,
1704                                        skip_emul_byte_cnt,
1705                                        0,
1706                                        0,
1707                                        !param->has_emulation_bytes,
1708                                        batch);
1709             break;
1710         }
1711     }
1712 }
1713
1714
1715 void intel_avc_slice_insert_packed_data(VADriverContextP ctx,
1716                                         struct encode_state *encode_state,
1717                                         struct intel_encoder_context *encoder_context,
1718                                         int slice_index,
1719                                         struct intel_batchbuffer *slice_batch)
1720 {
1721     int count, i, start_index;
1722     unsigned int length_in_bits;
1723     VAEncPackedHeaderParameterBuffer *param = NULL;
1724     unsigned int *header_data = NULL;
1725     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
1726     int slice_header_index;
1727     unsigned char *nal_type = NULL;
1728
1729     if (encode_state->slice_header_index[slice_index] == 0)
1730         slice_header_index = -1;
1731     else
1732         slice_header_index = (encode_state->slice_header_index[slice_index] & SLICE_PACKED_DATA_INDEX_MASK);
1733
1734     count = encode_state->slice_rawdata_count[slice_index];
1735     start_index = (encode_state->slice_rawdata_index[slice_index] & SLICE_PACKED_DATA_INDEX_MASK);
1736
1737     for (i = 0; i < count; i++) {
1738         unsigned int skip_emul_byte_cnt;
1739
1740         header_data = (unsigned int *)encode_state->packed_header_data_ext[start_index + i]->buffer;
1741         nal_type = (unsigned char *)header_data;
1742
1743         param = (VAEncPackedHeaderParameterBuffer *)
1744                 (encode_state->packed_header_params_ext[start_index + i]->buffer);
1745
1746         length_in_bits = param->bit_length;
1747
1748         skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
1749
1750         /* skip the slice header/AUD packed data type as it is lastly inserted */
1751         if (param->type == VAEncPackedHeaderSlice || (*(nal_type + skip_emul_byte_cnt - 1) & 0x1f) == AVC_NAL_DELIMITER)
1752             continue;
1753
1754         /* as the slice header is still required, the last header flag is set to
1755          * zero.
1756          */
1757         mfc_context->insert_object(ctx,
1758                                    encoder_context,
1759                                    header_data,
1760                                    ALIGN(length_in_bits, 32) >> 5,
1761                                    length_in_bits & 0x1f,
1762                                    skip_emul_byte_cnt,
1763                                    0,
1764                                    0,
1765                                    !param->has_emulation_bytes,
1766                                    slice_batch);
1767     }
1768
1769     if (slice_header_index == -1) {
1770         unsigned char *slice_header = NULL;
1771         int slice_header_length_in_bits = 0;
1772         VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
1773         VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
1774         VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[slice_index]->buffer;
1775
1776         /* No slice header data is passed. And the driver needs to generate it */
1777         /* For the Normal H264 */
1778         slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter,
1779                                                              pPicParameter,
1780                                                              pSliceParameter,
1781                                                              &slice_header);
1782         mfc_context->insert_object(ctx, encoder_context,
1783                                    (unsigned int *)slice_header,
1784                                    ALIGN(slice_header_length_in_bits, 32) >> 5,
1785                                    slice_header_length_in_bits & 0x1f,
1786                                    5,  /* first 5 bytes are start code + nal unit type */
1787                                    1, 0, 1, slice_batch);
1788
1789         free(slice_header);
1790     } else {
1791         unsigned int skip_emul_byte_cnt;
1792
1793         header_data = (unsigned int *)encode_state->packed_header_data_ext[slice_header_index]->buffer;
1794
1795         param = (VAEncPackedHeaderParameterBuffer *)
1796                 (encode_state->packed_header_params_ext[slice_header_index]->buffer);
1797         length_in_bits = param->bit_length;
1798
1799         /* as the slice header is the last header data for one slice,
1800          * the last header flag is set to one.
1801          */
1802         skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
1803
1804         mfc_context->insert_object(ctx,
1805                                    encoder_context,
1806                                    header_data,
1807                                    ALIGN(length_in_bits, 32) >> 5,
1808                                    length_in_bits & 0x1f,
1809                                    skip_emul_byte_cnt,
1810                                    1,
1811                                    0,
1812                                    !param->has_emulation_bytes,
1813                                    slice_batch);
1814     }
1815
1816     return;
1817 }
1818
1819 void
1820 intel_h264_initialize_mbmv_cost(VADriverContextP ctx,
1821                                 struct encode_state *encode_state,
1822                                 struct intel_encoder_context *encoder_context)
1823 {
1824     struct i965_driver_data *i965 = i965_driver_data(ctx);
1825     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1826     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1827     int qp;
1828     dri_bo *bo;
1829     uint8_t *cost_table;
1830
1831     int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1832
1833
1834     if (slice_type == SLICE_TYPE_I) {
1835         if (vme_context->i_qp_cost_table)
1836             return;
1837     } else if (slice_type == SLICE_TYPE_P) {
1838         if (vme_context->p_qp_cost_table)
1839             return;
1840     } else {
1841         if (vme_context->b_qp_cost_table)
1842             return;
1843     }
1844
1845     /* It is enough to allocate 32 bytes for each qp. */
1846     bo = dri_bo_alloc(i965->intel.bufmgr,
1847                       "cost_table ",
1848                       QP_MAX * 32,
1849                       64);
1850
1851     dri_bo_map(bo, 1);
1852     assert(bo->virtual);
1853     cost_table = (uint8_t *)(bo->virtual);
1854     for (qp = 0; qp < QP_MAX; qp++) {
1855         intel_h264_calc_mbmvcost_qp(qp, slice_type, cost_table);
1856         cost_table += 32;
1857     }
1858
1859     dri_bo_unmap(bo);
1860
1861     if (slice_type == SLICE_TYPE_I) {
1862         vme_context->i_qp_cost_table = bo;
1863     } else if (slice_type == SLICE_TYPE_P) {
1864         vme_context->p_qp_cost_table = bo;
1865     } else {
1866         vme_context->b_qp_cost_table = bo;
1867     }
1868
1869     vme_context->cost_table_size = QP_MAX * 32;
1870     return;
1871 }
1872
1873 extern void
1874 intel_h264_setup_cost_surface(VADriverContextP ctx,
1875                               struct encode_state *encode_state,
1876                               struct intel_encoder_context *encoder_context,
1877                               unsigned long binding_table_offset,
1878                               unsigned long surface_state_offset)
1879 {
1880     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1881     VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
1882     dri_bo *bo;
1883
1884
1885     struct i965_buffer_surface cost_table;
1886
1887     int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
1888
1889
1890     if (slice_type == SLICE_TYPE_I) {
1891         bo = vme_context->i_qp_cost_table;
1892     } else if (slice_type == SLICE_TYPE_P) {
1893         bo = vme_context->p_qp_cost_table;
1894     } else {
1895         bo = vme_context->b_qp_cost_table;
1896     }
1897
1898     cost_table.bo = bo;
1899     cost_table.num_blocks = QP_MAX;
1900     cost_table.pitch = 16;
1901     cost_table.size_block = 32;
1902
1903     vme_context->vme_buffer_suface_setup(ctx,
1904                                          &vme_context->gpe_context,
1905                                          &cost_table,
1906                                          binding_table_offset,
1907                                          surface_state_offset);
1908 }
1909
1910 /*
1911  * the idea of conversion between qp and qstep comes from scaling process
1912  * of transform coeff for Luma component in H264 spec.
1913  *   2^(Qpy / 6 - 6)
1914  * In order to avoid too small qstep, it is multiplied by 16.
1915  */
1916 static float intel_h264_qp_qstep(int qp)
1917 {
1918     float value, qstep;
1919     value = qp;
1920     value = value / 6 - 2;
1921     qstep = powf(2, value);
1922     return qstep;
1923 }
1924
1925 static int intel_h264_qstep_qp(float qstep)
1926 {
1927     float qp;
1928
1929     qp = 12.0f + 6.0f * log2f(qstep);
1930
1931     return floorf(qp);
1932 }
1933
1934 /*
1935  * Currently it is based on the following assumption:
1936  * SUM(roi_area * 1 / roi_qstep) + non_area * 1 / nonroi_qstep =
1937  *                 total_aread * 1 / baseqp_qstep
1938  *
1939  * qstep is the linearized quantizer of H264 quantizer
1940  */
1941 typedef struct {
1942     int row_start_in_mb;
1943     int row_end_in_mb;
1944     int col_start_in_mb;
1945     int col_end_in_mb;
1946
1947     int width_mbs;
1948     int height_mbs;
1949
1950     int roi_qp;
1951 } ROIRegionParam;
1952
1953 static VAStatus
1954 intel_h264_enc_roi_cbr(VADriverContextP ctx,
1955                        int base_qp,
1956                        struct encode_state *encode_state,
1957                        struct intel_encoder_context *encoder_context)
1958 {
1959     int nonroi_qp;
1960     int min_qp = MAX(1, encoder_context->brc.min_qp);
1961     bool quickfill = 0;
1962
1963     ROIRegionParam param_regions[I965_MAX_NUM_ROI_REGIONS];
1964     int num_roi = 0;
1965     int i, j;
1966
1967     float temp;
1968     float qstep_nonroi, qstep_base;
1969     float roi_area, total_area, nonroi_area;
1970     float sum_roi;
1971
1972     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
1973     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
1974     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
1975     int mbs_in_picture = width_in_mbs * height_in_mbs;
1976
1977     struct gen6_vme_context *vme_context = encoder_context->vme_context;
1978     VAStatus vaStatus = VA_STATUS_SUCCESS;
1979
1980     /* currently roi_value_is_qp_delta is the only supported mode of priority.
1981      *
1982      * qp_delta set by user is added to base_qp, which is then clapped by
1983      * [base_qp-min_delta, base_qp+max_delta].
1984      */
1985     ASSERT_RET(encoder_context->brc.roi_value_is_qp_delta, VA_STATUS_ERROR_INVALID_PARAMETER);
1986
1987     num_roi = encoder_context->brc.num_roi;
1988
1989     /* when the base_qp is lower than 12, the quality is quite good based
1990      * on the H264 test experience.
1991      * In such case it is unnecessary to adjust the quality for ROI region.
1992      */
1993     if (base_qp <= 12) {
1994         nonroi_qp = base_qp;
1995         quickfill = 1;
1996         goto qp_fill;
1997     }
1998
1999     sum_roi = 0.0f;
2000     roi_area = 0;
2001     for (i = 0; i < num_roi; i++) {
2002         int row_start, row_end, col_start, col_end;
2003         int roi_width_mbs, roi_height_mbs;
2004         int mbs_in_roi;
2005         int roi_qp;
2006         float qstep_roi;
2007
2008         col_start = encoder_context->brc.roi[i].left;
2009         col_end = encoder_context->brc.roi[i].right;
2010         row_start = encoder_context->brc.roi[i].top;
2011         row_end = encoder_context->brc.roi[i].bottom;
2012
2013         col_start = col_start / 16;
2014         col_end = (col_end + 15) / 16;
2015         row_start = row_start / 16;
2016         row_end = (row_end + 15) / 16;
2017
2018         roi_width_mbs = col_end - col_start;
2019         roi_height_mbs = row_end - row_start;
2020         mbs_in_roi = roi_width_mbs * roi_height_mbs;
2021
2022         param_regions[i].row_start_in_mb = row_start;
2023         param_regions[i].row_end_in_mb = row_end;
2024         param_regions[i].col_start_in_mb = col_start;
2025         param_regions[i].col_end_in_mb = col_end;
2026         param_regions[i].width_mbs = roi_width_mbs;
2027         param_regions[i].height_mbs = roi_height_mbs;
2028
2029         roi_qp = base_qp + encoder_context->brc.roi[i].value;
2030         BRC_CLIP(roi_qp, min_qp, 51);
2031
2032         param_regions[i].roi_qp = roi_qp;
2033         qstep_roi = intel_h264_qp_qstep(roi_qp);
2034
2035         roi_area += mbs_in_roi;
2036         sum_roi += mbs_in_roi / qstep_roi;
2037     }
2038
2039     total_area = mbs_in_picture;
2040     nonroi_area = total_area - roi_area;
2041
2042     qstep_base = intel_h264_qp_qstep(base_qp);
2043     temp = (total_area / qstep_base - sum_roi);
2044
2045     if (temp < 0) {
2046         nonroi_qp = 51;
2047     } else {
2048         qstep_nonroi = nonroi_area / temp;
2049         nonroi_qp = intel_h264_qstep_qp(qstep_nonroi);
2050     }
2051
2052     BRC_CLIP(nonroi_qp, min_qp, 51);
2053
2054 qp_fill:
2055     memset(vme_context->qp_per_mb, nonroi_qp, mbs_in_picture);
2056     if (!quickfill) {
2057         char *qp_ptr;
2058
2059         for (i = 0; i < num_roi; i++) {
2060             for (j = param_regions[i].row_start_in_mb; j < param_regions[i].row_end_in_mb; j++) {
2061                 qp_ptr = vme_context->qp_per_mb + (j * width_in_mbs) + param_regions[i].col_start_in_mb;
2062                 memset(qp_ptr, param_regions[i].roi_qp, param_regions[i].width_mbs);
2063             }
2064         }
2065     }
2066     return vaStatus;
2067 }
2068
2069 extern void
2070 intel_h264_enc_roi_config(VADriverContextP ctx,
2071                           struct encode_state *encode_state,
2072                           struct intel_encoder_context *encoder_context)
2073 {
2074     char *qp_ptr;
2075     int i, j;
2076     struct i965_driver_data *i965 = i965_driver_data(ctx);
2077     struct gen6_vme_context *vme_context = encoder_context->vme_context;
2078     struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
2079     VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
2080     int width_in_mbs = pSequenceParameter->picture_width_in_mbs;
2081     int height_in_mbs = pSequenceParameter->picture_height_in_mbs;
2082
2083     int row_start, row_end, col_start, col_end;
2084     int num_roi = 0;
2085
2086     vme_context->roi_enabled = 0;
2087     /* Restriction: Disable ROI when multi-slice is enabled */
2088     if (!encoder_context->context_roi || (encode_state->num_slice_params_ext > 1))
2089         return;
2090
2091     vme_context->roi_enabled = !!encoder_context->brc.num_roi;
2092
2093     if (!vme_context->roi_enabled)
2094         return;
2095
2096     num_roi = encoder_context->brc.num_roi;
2097
2098     if ((vme_context->saved_width_mbs !=  width_in_mbs) ||
2099         (vme_context->saved_height_mbs != height_in_mbs)) {
2100         free(vme_context->qp_per_mb);
2101         vme_context->qp_per_mb = calloc(1, width_in_mbs * height_in_mbs);
2102
2103         vme_context->saved_width_mbs = width_in_mbs;
2104         vme_context->saved_height_mbs = height_in_mbs;
2105         assert(vme_context->qp_per_mb);
2106     }
2107     if (encoder_context->rate_control_mode == VA_RC_CBR) {
2108         /*
2109          * TODO: More complex Qp adjust needs to be added.
2110          * Currently it is initialized to slice_qp.
2111          */
2112         VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
2113         int qp;
2114         int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
2115
2116         qp = mfc_context->brc.qp_prime_y[encoder_context->layer.curr_frame_layer_id][slice_type];
2117         intel_h264_enc_roi_cbr(ctx, qp, encode_state, encoder_context);
2118
2119     } else if (encoder_context->rate_control_mode == VA_RC_CQP) {
2120         VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
2121         VAEncSliceParameterBufferH264 *slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer;
2122         int qp;
2123         int min_qp = MAX(1, encoder_context->brc.min_qp);
2124
2125         qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
2126         memset(vme_context->qp_per_mb, qp, width_in_mbs * height_in_mbs);
2127
2128
2129         for (j = num_roi; j ; j--) {
2130             int qp_delta, qp_clip;
2131
2132             col_start = encoder_context->brc.roi[j].left;
2133             col_end = encoder_context->brc.roi[j].right;
2134             row_start = encoder_context->brc.roi[j].top;
2135             row_end = encoder_context->brc.roi[j].bottom;
2136
2137             col_start = col_start / 16;
2138             col_end = (col_end + 15) / 16;
2139             row_start = row_start / 16;
2140             row_end = (row_end + 15) / 16;
2141
2142             qp_delta = encoder_context->brc.roi[j].value;
2143             qp_clip = qp + qp_delta;
2144
2145             BRC_CLIP(qp_clip, min_qp, 51);
2146
2147             for (i = row_start; i < row_end; i++) {
2148                 qp_ptr = vme_context->qp_per_mb + (i * width_in_mbs) + col_start;
2149                 memset(qp_ptr, qp_clip, (col_end - col_start));
2150             }
2151         }
2152     } else {
2153         /*
2154          * TODO: Disable it for non CBR-CQP.
2155          */
2156         vme_context->roi_enabled = 0;
2157     }
2158
2159     if (vme_context->roi_enabled && IS_GEN7(i965->intel.device_info))
2160         encoder_context->soft_batch_force = 1;
2161
2162     return;
2163 }
2164
2165 /* HEVC */
2166 static int
2167 hevc_temporal_find_surface(VAPictureHEVC *curr_pic,
2168                            VAPictureHEVC *ref_list,
2169                            int num_pictures,
2170                            int dir)
2171 {
2172     int i, found = -1, min = 0x7FFFFFFF;
2173
2174     for (i = 0; i < num_pictures; i++) {
2175         int tmp;
2176
2177         if ((ref_list[i].flags & VA_PICTURE_HEVC_INVALID) ||
2178             (ref_list[i].picture_id == VA_INVALID_SURFACE))
2179             break;
2180
2181         tmp = curr_pic->pic_order_cnt - ref_list[i].pic_order_cnt;
2182
2183         if (dir)
2184             tmp = -tmp;
2185
2186         if (tmp > 0 && tmp < min) {
2187             min = tmp;
2188             found = i;
2189         }
2190     }
2191
2192     return found;
2193 }
2194 void
2195 intel_hevc_vme_reference_state(VADriverContextP ctx,
2196                                struct encode_state *encode_state,
2197                                struct intel_encoder_context *encoder_context,
2198                                int list_index,
2199                                int surface_index,
2200                                void (* vme_source_surface_state)(
2201                                    VADriverContextP ctx,
2202                                    int index,
2203                                    struct object_surface *obj_surface,
2204                                    struct intel_encoder_context *encoder_context))
2205 {
2206     struct gen6_vme_context *vme_context = encoder_context->vme_context;
2207     struct object_surface *obj_surface = NULL;
2208     struct i965_driver_data *i965 = i965_driver_data(ctx);
2209     VASurfaceID ref_surface_id;
2210     VAEncSequenceParameterBufferHEVC *pSequenceParameter = (VAEncSequenceParameterBufferHEVC *)encode_state->seq_param_ext->buffer;
2211     VAEncPictureParameterBufferHEVC *pic_param = (VAEncPictureParameterBufferHEVC *)encode_state->pic_param_ext->buffer;
2212     VAEncSliceParameterBufferHEVC *slice_param = (VAEncSliceParameterBufferHEVC *)encode_state->slice_params_ext[0]->buffer;
2213     int max_num_references;
2214     VAPictureHEVC *curr_pic;
2215     VAPictureHEVC *ref_list;
2216     int ref_idx;
2217     unsigned int is_hevc10 = 0;
2218     GenHevcSurface *hevc_encoder_surface = NULL;
2219
2220     if ((pSequenceParameter->seq_fields.bits.bit_depth_luma_minus8 > 0)
2221         || (pSequenceParameter->seq_fields.bits.bit_depth_chroma_minus8 > 0))
2222         is_hevc10 = 1;
2223
2224     if (list_index == 0) {
2225         max_num_references = pic_param->num_ref_idx_l0_default_active_minus1 + 1;
2226         ref_list = slice_param->ref_pic_list0;
2227     } else {
2228         max_num_references = pic_param->num_ref_idx_l1_default_active_minus1 + 1;
2229         ref_list = slice_param->ref_pic_list1;
2230     }
2231
2232     if (max_num_references == 1) {
2233         if (list_index == 0) {
2234             ref_surface_id = slice_param->ref_pic_list0[0].picture_id;
2235             vme_context->used_references[0] = &slice_param->ref_pic_list0[0];
2236         } else {
2237             ref_surface_id = slice_param->ref_pic_list1[0].picture_id;
2238             vme_context->used_references[1] = &slice_param->ref_pic_list1[0];
2239         }
2240
2241         if (ref_surface_id != VA_INVALID_SURFACE)
2242             obj_surface = SURFACE(ref_surface_id);
2243
2244         if (!obj_surface ||
2245             !obj_surface->bo) {
2246             obj_surface = encode_state->reference_objects[list_index];
2247             vme_context->used_references[list_index] = &pic_param->reference_frames[list_index];
2248         }
2249
2250         ref_idx = 0;
2251     } else {
2252         curr_pic = &pic_param->decoded_curr_pic;
2253
2254         /* select the reference frame in temporal space */
2255         ref_idx = hevc_temporal_find_surface(curr_pic, ref_list, max_num_references, list_index == 1);
2256         ref_surface_id = ref_list[ref_idx].picture_id;
2257
2258         if (ref_surface_id != VA_INVALID_SURFACE) /* otherwise warning later */
2259             obj_surface = SURFACE(ref_surface_id);
2260
2261         vme_context->used_reference_objects[list_index] = obj_surface;
2262         vme_context->used_references[list_index] = &ref_list[ref_idx];
2263     }
2264
2265     if (obj_surface &&
2266         obj_surface->bo) {
2267         assert(ref_idx >= 0);
2268         vme_context->used_reference_objects[list_index] = obj_surface;
2269
2270         if (is_hevc10) {
2271             hevc_encoder_surface = (GenHevcSurface *) obj_surface->private_data;
2272             assert(hevc_encoder_surface);
2273             obj_surface = hevc_encoder_surface->nv12_surface_obj;
2274         }
2275         vme_source_surface_state(ctx, surface_index, obj_surface, encoder_context);
2276         vme_context->ref_index_in_mb[list_index] = (ref_idx << 24 |
2277                                                     ref_idx << 16 |
2278                                                     ref_idx <<  8 |
2279                                                     ref_idx);
2280     } else {
2281         vme_context->used_reference_objects[list_index] = NULL;
2282         vme_context->used_references[list_index] = NULL;
2283         vme_context->ref_index_in_mb[list_index] = 0;
2284     }
2285 }
2286
2287 void intel_vme_hevc_update_mbmv_cost(VADriverContextP ctx,
2288                                      struct encode_state *encode_state,
2289                                      struct intel_encoder_context *encoder_context)
2290 {
2291     struct gen9_hcpe_context *mfc_context = encoder_context->mfc_context;
2292     struct gen6_vme_context *vme_context = encoder_context->vme_context;
2293     VAEncPictureParameterBufferHEVC *pic_param = (VAEncPictureParameterBufferHEVC *)encode_state->pic_param_ext->buffer;
2294     VAEncSliceParameterBufferHEVC *slice_param = (VAEncSliceParameterBufferHEVC *)encode_state->slice_params_ext[0]->buffer;
2295     VAEncSequenceParameterBufferHEVC *pSequenceParameter = (VAEncSequenceParameterBufferHEVC *)encode_state->seq_param_ext->buffer;
2296     int qp, m_cost, j, mv_count;
2297     uint8_t *vme_state_message = (uint8_t *)(vme_context->vme_state_message);
2298     float   lambda, m_costf;
2299
2300     /* here no SI SP slice for HEVC, do not need slice fixup */
2301     int slice_type = slice_param->slice_type;
2302
2303
2304     qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
2305
2306     if (encoder_context->rate_control_mode == VA_RC_CBR) {
2307         qp = mfc_context->bit_rate_control_context[slice_type].QpPrimeY;
2308         if (slice_type == HEVC_SLICE_B) {
2309             if (pSequenceParameter->ip_period == 1) {
2310                 slice_type = HEVC_SLICE_P;
2311                 qp = mfc_context->bit_rate_control_context[HEVC_SLICE_P].QpPrimeY;
2312
2313             } else if (mfc_context->vui_hrd.i_frame_number % pSequenceParameter->ip_period == 1) {
2314                 slice_type = HEVC_SLICE_P;
2315                 qp = mfc_context->bit_rate_control_context[HEVC_SLICE_P].QpPrimeY;
2316             }
2317         }
2318
2319     }
2320
2321     if (vme_state_message == NULL)
2322         return;
2323
2324     assert(qp <= QP_MAX);
2325     lambda = intel_lambda_qp(qp);
2326     if (slice_type == HEVC_SLICE_I) {
2327         vme_state_message[MODE_INTRA_16X16] = 0;
2328         m_cost = lambda * 4;
2329         vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
2330         m_cost = lambda * 16;
2331         vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
2332         m_cost = lambda * 3;
2333         vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
2334     } else {
2335         m_cost = 0;
2336         vme_state_message[MODE_INTER_MV0] = intel_format_lutvalue(m_cost, 0x6f);
2337         for (j = 1; j < 3; j++) {
2338             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
2339             m_cost = (int)m_costf;
2340             vme_state_message[MODE_INTER_MV0 + j] = intel_format_lutvalue(m_cost, 0x6f);
2341         }
2342         mv_count = 3;
2343         for (j = 4; j <= 64; j *= 2) {
2344             m_costf = (log2f((float)(j + 1)) + 1.718f) * lambda;
2345             m_cost = (int)m_costf;
2346             vme_state_message[MODE_INTER_MV0 + mv_count] = intel_format_lutvalue(m_cost, 0x6f);
2347             mv_count++;
2348         }
2349
2350         if (qp <= 25) {
2351             vme_state_message[MODE_INTRA_16X16] = 0x4a;
2352             vme_state_message[MODE_INTRA_8X8] = 0x4a;
2353             vme_state_message[MODE_INTRA_4X4] = 0x4a;
2354             vme_state_message[MODE_INTRA_NONPRED] = 0x4a;
2355             vme_state_message[MODE_INTER_16X16] = 0x4a;
2356             vme_state_message[MODE_INTER_16X8] = 0x4a;
2357             vme_state_message[MODE_INTER_8X8] = 0x4a;
2358             vme_state_message[MODE_INTER_8X4] = 0x4a;
2359             vme_state_message[MODE_INTER_4X4] = 0x4a;
2360             vme_state_message[MODE_INTER_BWD] = 0x2a;
2361             return;
2362         }
2363         m_costf = lambda * 10;
2364         vme_state_message[MODE_INTRA_16X16] = intel_format_lutvalue(m_cost, 0x8f);
2365         m_cost = lambda * 14;
2366         vme_state_message[MODE_INTRA_8X8] = intel_format_lutvalue(m_cost, 0x8f);
2367         m_cost = lambda * 24;
2368         vme_state_message[MODE_INTRA_4X4] = intel_format_lutvalue(m_cost, 0x8f);
2369         m_costf = lambda * 3.5;
2370         m_cost = m_costf;
2371         vme_state_message[MODE_INTRA_NONPRED] = intel_format_lutvalue(m_cost, 0x6f);
2372         if (slice_type == HEVC_SLICE_P) {
2373             m_costf = lambda * 2.5;
2374             m_cost = m_costf;
2375             vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
2376             m_costf = lambda * 4;
2377             m_cost = m_costf;
2378             vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
2379             m_costf = lambda * 1.5;
2380             m_cost = m_costf;
2381             vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
2382             m_costf = lambda * 3;
2383             m_cost = m_costf;
2384             vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
2385             m_costf = lambda * 5;
2386             m_cost = m_costf;
2387             vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
2388             /* BWD is not used in P-frame */
2389             vme_state_message[MODE_INTER_BWD] = 0;
2390         } else {
2391             m_costf = lambda * 2.5;
2392             m_cost = m_costf;
2393             vme_state_message[MODE_INTER_16X16] = intel_format_lutvalue(m_cost, 0x8f);
2394             m_costf = lambda * 5.5;
2395             m_cost = m_costf;
2396             vme_state_message[MODE_INTER_16X8] = intel_format_lutvalue(m_cost, 0x8f);
2397             m_costf = lambda * 3.5;
2398             m_cost = m_costf;
2399             vme_state_message[MODE_INTER_8X8] = intel_format_lutvalue(m_cost, 0x6f);
2400             m_costf = lambda * 5.0;
2401             m_cost = m_costf;
2402             vme_state_message[MODE_INTER_8X4] = intel_format_lutvalue(m_cost, 0x6f);
2403             m_costf = lambda * 6.5;
2404             m_cost = m_costf;
2405             vme_state_message[MODE_INTER_4X4] = intel_format_lutvalue(m_cost, 0x6f);
2406             m_costf = lambda * 1.5;
2407             m_cost = m_costf;
2408             vme_state_message[MODE_INTER_BWD] = intel_format_lutvalue(m_cost, 0x6f);
2409         }
2410     }
2411 }