rdopt.c 85 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9 10 11 12 13 14 15
 */


#include <stdio.h>
#include <math.h>
#include <limits.h>
#include <assert.h>
16 17
#include "vpx_config.h"
#include "vpx_rtcd.h"
John Koleszar's avatar
John Koleszar committed
18
#include "vp8/common/pragmas.h"
John Koleszar's avatar
John Koleszar committed
19 20 21 22 23
#include "tokenize.h"
#include "treewriter.h"
#include "onyx_int.h"
#include "modecosts.h"
#include "encodeintra.h"
24
#include "pickinter.h"
John Koleszar's avatar
John Koleszar committed
25 26 27 28
#include "vp8/common/entropymode.h"
#include "vp8/common/reconinter.h"
#include "vp8/common/reconintra4x4.h"
#include "vp8/common/findnearmv.h"
29
#include "vp8/common/quant_common.h"
John Koleszar's avatar
John Koleszar committed
30 31
#include "encodemb.h"
#include "quantize.h"
32
#include "vp8/common/variance.h"
John Koleszar's avatar
John Koleszar committed
33
#include "mcomp.h"
Yunqing Wang's avatar
Yunqing Wang committed
34
#include "rdopt.h"
John Koleszar's avatar
John Koleszar committed
35
#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
36
#include "vp8/common/systemdependent.h"
37 38 39
#if CONFIG_TEMPORAL_DENOISING
#include "denoising.h"
#endif
Scott LaVarnway's avatar
Scott LaVarnway committed
40 41
extern void vp8_update_zbin_extra(VP8_COMP *cpi, MACROBLOCK *x);

John Koleszar's avatar
John Koleszar committed
42 43
#define MAXF(a,b)            (((a) > (b)) ? (a) : (b))

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
typedef struct rate_distortion_struct
{
    int rate2;
    int rate_y;
    int rate_uv;
    int distortion2;
    int distortion_uv;
} RATE_DISTORTION;

typedef struct best_mode_struct
{
  int yrd;
  int rd;
  int intra_rd;
  MB_MODE_INFO mbmode;
  union b_mode_info bmodes[16];
  PARTITION_INFO partition;
} BEST_MODE;

63
static const int auto_speed_thresh[17] =
John Koleszar's avatar
John Koleszar committed
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
{
    1000,
    200,
    150,
    130,
    150,
    125,
    120,
    115,
    115,
    115,
    115,
    115,
    115,
    115,
    115,
    115,
    105
};

const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES] =
{
    ZEROMV,
    DC_PRED,

    NEARESTMV,
    NEARMV,

    ZEROMV,
    NEARESTMV,

    ZEROMV,
    NEARESTMV,

    NEARMV,
    NEARMV,

    V_PRED,
    H_PRED,
    TM_PRED,

    NEWMV,
    NEWMV,
    NEWMV,

    SPLITMV,
    SPLITMV,
    SPLITMV,

    B_PRED,
};

116 117 118 119
/* This table determines the search order in reference frame priority order,
 * which may not necessarily match INTRA,LAST,GOLDEN,ARF
 */
const int vp8_ref_frame_order[MAX_MODES] =
John Koleszar's avatar
John Koleszar committed
120
{
121 122
    1,
    0,
John Koleszar's avatar
John Koleszar committed
123

124 125
    1,
    1,
John Koleszar's avatar
John Koleszar committed
126

127 128
    2,
    2,
John Koleszar's avatar
John Koleszar committed
129

130 131
    3,
    3,
John Koleszar's avatar
John Koleszar committed
132

133 134
    2,
    3,
John Koleszar's avatar
John Koleszar committed
135

136 137 138
    0,
    0,
    0,
John Koleszar's avatar
John Koleszar committed
139

140 141 142
    1,
    2,
    3,
John Koleszar's avatar
John Koleszar committed
143

144 145 146
    1,
    2,
    3,
John Koleszar's avatar
John Koleszar committed
147

148
    0,
John Koleszar's avatar
John Koleszar committed
149 150 151
};

static void fill_token_costs(
152 153
    unsigned int c      [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS],
    const vp8_prob p    [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES]
John Koleszar's avatar
John Koleszar committed
154 155 156 157 158 159 160 161
)
{
    int i, j, k;


    for (i = 0; i < BLOCK_TYPES; i++)
        for (j = 0; j < COEF_BANDS; j++)
            for (k = 0; k < PREV_COEF_CONTEXTS; k++)
Jim Bankoski's avatar
Jim Bankoski committed
162 163 164 165 166
                // check for pt=0 and band > 1 if block type 0 and 0 if blocktype 1
                if(k==0 && j>(i==0) )
                    vp8_cost_tokens2((int *)(c [i][j][k]), p [i][j][k], vp8_coef_tree,2);
                else
                    vp8_cost_tokens((int *)(c [i][j][k]), p [i][j][k], vp8_coef_tree);
John Koleszar's avatar
John Koleszar committed
167 168
}

Paul Wilkins's avatar
Paul Wilkins committed
169
static int rd_iifactor [ 32 ] =  {    4,   4,   3,   2,   1,   0,   0,   0,
John Koleszar's avatar
John Koleszar committed
170 171 172 173 174
                                      0,   0,   0,   0,   0,   0,   0,   0,
                                      0,   0,   0,   0,   0,   0,   0,   0,
                                      0,   0,   0,   0,   0,   0,   0,   0,
                                 };

175 176
/* values are now correlated to quantizer */
static int sad_per_bit16lut[QINDEX_RANGE] =
John Koleszar's avatar
John Koleszar committed
177
{
Yaowu Xu's avatar
Yaowu Xu committed
178 179 180 181 182 183
    2,  2,  2,  2,  2,  2,  2,  2,
    2,  2,  2,  2,  2,  2,  2,  2,
    3,  3,  3,  3,  3,  3,  3,  3,
    3,  3,  3,  3,  3,  3,  4,  4,
    4,  4,  4,  4,  4,  4,  4,  4,
    4,  4,  5,  5,  5,  5,  5,  5,
184
    5,  5,  5,  5,  5,  5,  6,  6,
Yaowu Xu's avatar
Yaowu Xu committed
185 186 187 188 189 190 191 192 193
    6,  6,  6,  6,  6,  6,  6,  6,
    6,  6,  7,  7,  7,  7,  7,  7,
    7,  7,  7,  7,  7,  7,  8,  8,
    8,  8,  8,  8,  8,  8,  8,  8,
    8,  8,  9,  9,  9,  9,  9,  9,
    9,  9,  9,  9,  9,  9,  10, 10,
    10, 10, 10, 10, 10, 10, 11, 11,
    11, 11, 11, 11, 12, 12, 12, 12,
    12, 12, 13, 13, 13, 13, 14, 14
John Koleszar's avatar
John Koleszar committed
194
};
195
static int sad_per_bit4lut[QINDEX_RANGE] =
John Koleszar's avatar
John Koleszar committed
196
{
Yaowu Xu's avatar
Yaowu Xu committed
197 198 199 200 201 202 203
    2,  2,  2,  2,  2,  2,  3,  3,
    3,  3,  3,  3,  3,  3,  3,  3,
    3,  3,  3,  3,  4,  4,  4,  4,
    4,  4,  4,  4,  4,  4,  5,  5,
    5,  5,  5,  5,  6,  6,  6,  6,
    6,  6,  6,  6,  6,  6,  6,  6,
    7,  7,  7,  7,  7,  7,  7,  7,
204
    7,  7,  7,  7,  7,  8,  8,  8,
Yaowu Xu's avatar
Yaowu Xu committed
205 206 207 208 209 210 211 212
    8,  8,  9,  9,  9,  9,  9,  9,
    10, 10, 10, 10, 10, 10, 10, 10,
    11, 11, 11, 11, 11, 11, 11, 11,
    12, 12, 12, 12, 12, 12, 12, 12,
    13, 13, 13, 13, 13, 13, 13, 14,
    14, 14, 14, 14, 15, 15, 15, 15,
    16, 16, 16, 16, 17, 17, 17, 18,
    18, 18, 19, 19, 19, 20, 20, 20,
John Koleszar's avatar
John Koleszar committed
213 214 215 216
};

void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex)
{
Yaowu Xu's avatar
Yaowu Xu committed
217 218
    cpi->mb.sadperbit16 =  sad_per_bit16lut[QIndex];
    cpi->mb.sadperbit4  =  sad_per_bit4lut[QIndex];
John Koleszar's avatar
John Koleszar committed
219 220 221 222 223 224
}

void vp8_initialize_rd_consts(VP8_COMP *cpi, int Qvalue)
{
    int q;
    int i;
225
    double capped_q = (Qvalue < 160) ? (double)Qvalue : 160.0;
Jim Bankoski's avatar
Jim Bankoski committed
226
    double rdconst = 2.80;
John Koleszar's avatar
John Koleszar committed
227 228 229

    vp8_clear_system_state();  //__asm emms;

230 231 232 233 234
    // Further tests required to see if optimum is different
    // for key frames, golden frames and arf frames.
    // if (cpi->common.refresh_golden_frame ||
    //     cpi->common.refresh_alt_ref_frame)
    cpi->RDMULT = (int)(rdconst * (capped_q * capped_q));
John Koleszar's avatar
John Koleszar committed
235

236 237 238 239 240 241 242 243 244 245 246 247
    // Extend rate multiplier along side quantizer zbin increases
    if (cpi->zbin_over_quant  > 0)
    {
        double oq_factor;
        double modq;

        // Experimental code using the same basic equation as used for Q above
        // The units of cpi->zbin_over_quant are 1/128 of Q bin size
        oq_factor = 1.0 + ((double)0.0015625 * cpi->zbin_over_quant);
        modq = (int)((double)capped_q * oq_factor);
        cpi->RDMULT = (int)(rdconst * (modq * modq));
    }
John Koleszar's avatar
John Koleszar committed
248

Paul Wilkins's avatar
Paul Wilkins committed
249
    if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME))
John Koleszar's avatar
John Koleszar committed
250
    {
251
        if (cpi->twopass.next_iiratio > 31)
Paul Wilkins's avatar
Paul Wilkins committed
252
            cpi->RDMULT += (cpi->RDMULT * rd_iifactor[31]) >> 4;
John Koleszar's avatar
John Koleszar committed
253
        else
254 255
            cpi->RDMULT +=
                (cpi->RDMULT * rd_iifactor[cpi->twopass.next_iiratio]) >> 4;
John Koleszar's avatar
John Koleszar committed
256 257
    }

258
    cpi->mb.errorperbit = (cpi->RDMULT / 110);
259 260
    cpi->mb.errorperbit += (cpi->mb.errorperbit==0);

John Koleszar's avatar
John Koleszar committed
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
    vp8_set_speed_features(cpi);

    q = (int)pow(Qvalue, 1.25);

    if (q < 8)
        q = 8;

    if (cpi->RDMULT > 1000)
    {
        cpi->RDDIV = 1;
        cpi->RDMULT /= 100;

        for (i = 0; i < MAX_MODES; i++)
        {
            if (cpi->sf.thresh_mult[i] < INT_MAX)
            {
                cpi->rd_threshes[i] = cpi->sf.thresh_mult[i] * q / 100;
            }
            else
            {
                cpi->rd_threshes[i] = INT_MAX;
            }

            cpi->rd_baseline_thresh[i] = cpi->rd_threshes[i];
        }
    }
    else
    {
        cpi->RDDIV = 100;

        for (i = 0; i < MAX_MODES; i++)
        {
            if (cpi->sf.thresh_mult[i] < (INT_MAX / q))
            {
                cpi->rd_threshes[i] = cpi->sf.thresh_mult[i] * q;
            }
            else
            {
                cpi->rd_threshes[i] = INT_MAX;
            }

            cpi->rd_baseline_thresh[i] = cpi->rd_threshes[i];
        }
    }

306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
    {
      // build token cost array for the type of frame we have now
      FRAME_CONTEXT *l = &cpi->lfc_n;

      if(cpi->common.refresh_alt_ref_frame)
          l = &cpi->lfc_a;
      else if(cpi->common.refresh_golden_frame)
          l = &cpi->lfc_g;

      fill_token_costs(
          cpi->mb.token_costs,
          (const vp8_prob( *)[8][3][11]) l->coef_probs
      );
      /*
      fill_token_costs(
          cpi->mb.token_costs,
          (const vp8_prob( *)[8][3][11]) cpi->common.fc.coef_probs);
      */

John Koleszar's avatar
John Koleszar committed
325

326 327 328 329 330 331 332
      // TODO make these mode costs depend on last,alt or gold too.  (jbb)
      vp8_init_mode_costs(cpi);

      // TODO figure onnnnuut why making mv cost frame type dependent didn't help (jbb)
      //vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) l->mvc, flags);

    }
John Koleszar's avatar
John Koleszar committed
333 334 335 336 337

}

void vp8_auto_select_speed(VP8_COMP *cpi)
{
338
    int milliseconds_for_compress = (int)(1000000 / cpi->frame_rate);
John Koleszar's avatar
John Koleszar committed
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357

    milliseconds_for_compress = milliseconds_for_compress * (16 - cpi->oxcf.cpu_used) / 16;

#if 0

    if (0)
    {
        FILE *f;

        f = fopen("speed.stt", "a");
        fprintf(f, " %8ld %10ld %10ld %10ld\n",
                cpi->common.current_video_frame, cpi->Speed, milliseconds_for_compress, cpi->avg_pick_mode_time);
        fclose(f);
    }

#endif

    /*
    // this is done during parameter valid check
Johann's avatar
Johann committed
358 359 360 361
    if( cpi->oxcf.cpu_used > 16)
        cpi->oxcf.cpu_used = 16;
    if( cpi->oxcf.cpu_used < -16)
        cpi->oxcf.cpu_used = -16;
John Koleszar's avatar
John Koleszar committed
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
    */

    if (cpi->avg_pick_mode_time < milliseconds_for_compress && (cpi->avg_encode_time - cpi->avg_pick_mode_time) < milliseconds_for_compress)
    {
        if (cpi->avg_pick_mode_time == 0)
        {
            cpi->Speed = 4;
        }
        else
        {
            if (milliseconds_for_compress * 100 < cpi->avg_encode_time * 95)
            {
                cpi->Speed          += 2;
                cpi->avg_pick_mode_time = 0;
                cpi->avg_encode_time = 0;

                if (cpi->Speed > 16)
                {
                    cpi->Speed = 16;
                }
            }

384
            if (milliseconds_for_compress * 100 > cpi->avg_encode_time * auto_speed_thresh[cpi->Speed])
John Koleszar's avatar
John Koleszar committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
            {
                cpi->Speed          -= 1;
                cpi->avg_pick_mode_time = 0;
                cpi->avg_encode_time = 0;

                // In real-time mode, cpi->speed is in [4, 16].
                if (cpi->Speed < 4)        //if ( cpi->Speed < 0 )
                {
                    cpi->Speed = 4;        //cpi->Speed = 0;
                }
            }
        }
    }
    else
    {
        cpi->Speed += 4;

        if (cpi->Speed > 16)
            cpi->Speed = 16;


        cpi->avg_pick_mode_time = 0;
        cpi->avg_encode_time = 0;
    }
}

int vp8_block_error_c(short *coeff, short *dqcoeff)
{
    int i;
    int error = 0;

    for (i = 0; i < 16; i++)
    {
        int this_diff = coeff[i] - dqcoeff[i];
        error += this_diff * this_diff;
    }

    return error;
}

int vp8_mbblock_error_c(MACROBLOCK *mb, int dc)
{
    BLOCK  *be;
    BLOCKD *bd;
    int i, j;
    int berror, error = 0;

    for (i = 0; i < 16; i++)
    {
        be = &mb->block[i];
        bd = &mb->e_mbd.block[i];

        berror = 0;

        for (j = dc; j < 16; j++)
        {
            int this_diff = be->coeff[j] - bd->dqcoeff[j];
            berror += this_diff * this_diff;
        }

        error += berror;
    }

    return error;
}

int vp8_mbuverror_c(MACROBLOCK *mb)
{

    BLOCK  *be;
    BLOCKD *bd;


    int i;
    int error = 0;

    for (i = 16; i < 24; i++)
    {
        be = &mb->block[i];
        bd = &mb->e_mbd.block[i];

        error += vp8_block_error_c(be->coeff, bd->dqcoeff);
    }

    return error;
}

John Koleszar's avatar
John Koleszar committed
472
int VP8_UVSSE(MACROBLOCK *x)
John Koleszar's avatar
John Koleszar committed
473 474 475 476 477 478 479 480
{
    unsigned char *uptr, *vptr;
    unsigned char *upred_ptr = (*(x->block[16].base_src) + x->block[16].src);
    unsigned char *vpred_ptr = (*(x->block[20].base_src) + x->block[20].src);
    int uv_stride = x->block[16].src_stride;

    unsigned int sse1 = 0;
    unsigned int sse2 = 0;
481 482
    int mv_row = x->e_mbd.mode_info_context->mbmi.mv.as_mv.row;
    int mv_col = x->e_mbd.mode_info_context->mbmi.mv.as_mv.col;
John Koleszar's avatar
John Koleszar committed
483
    int offset;
Scott LaVarnway's avatar
Scott LaVarnway committed
484
    int pre_stride = x->e_mbd.pre.uv_stride;
John Koleszar's avatar
John Koleszar committed
485

486 487 488 489 490 491 492 493 494 495 496 497
    if (mv_row < 0)
        mv_row -= 1;
    else
        mv_row += 1;

    if (mv_col < 0)
        mv_col -= 1;
    else
        mv_col += 1;

    mv_row /= 2;
    mv_col /= 2;
John Koleszar's avatar
John Koleszar committed
498 499 500 501 502 503 504

    offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
    uptr = x->e_mbd.pre.u_buffer + offset;
    vptr = x->e_mbd.pre.v_buffer + offset;

    if ((mv_row | mv_col) & 7)
    {
John Koleszar's avatar
John Koleszar committed
505
        vp8_sub_pixel_variance8x8(uptr, pre_stride,
506
            mv_col & 7, mv_row & 7, upred_ptr, uv_stride, &sse2);
John Koleszar's avatar
John Koleszar committed
507
        vp8_sub_pixel_variance8x8(vptr, pre_stride,
508
            mv_col & 7, mv_row & 7, vpred_ptr, uv_stride, &sse1);
John Koleszar's avatar
John Koleszar committed
509 510 511 512
        sse2 += sse1;
    }
    else
    {
John Koleszar's avatar
John Koleszar committed
513
        vp8_variance8x8(uptr, pre_stride,
514
            upred_ptr, uv_stride, &sse2);
John Koleszar's avatar
John Koleszar committed
515
        vp8_variance8x8(vptr, pre_stride,
516
            vpred_ptr, uv_stride, &sse1);
John Koleszar's avatar
John Koleszar committed
517 518 519 520 521 522 523 524 525
        sse2 += sse1;
    }
    return sse2;

}

static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type, ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l)
{
    int c = !type;              /* start at coef 0, unless Y with Y2 */
526
    int eob = (int)(*b->eob);
John Koleszar's avatar
John Koleszar committed
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
    int pt ;    /* surrounding block/prev coef predictor */
    int cost = 0;
    short *qcoeff_ptr = b->qcoeff;

    VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);

# define QC( I)  ( qcoeff_ptr [vp8_default_zig_zag1d[I]] )

    for (; c < eob; c++)
    {
        int v = QC(c);
        int t = vp8_dct_value_tokens_ptr[v].Token;
        cost += mb->token_costs [type] [vp8_coef_bands[c]] [pt] [t];
        cost += vp8_dct_value_cost_ptr[v];
        pt = vp8_prev_token_class[t];
    }

# undef QC

    if (c < 16)
        cost += mb->token_costs [type] [vp8_coef_bands[c]] [pt] [DCT_EOB_TOKEN];

    pt = (c != !type); // is eob first coefficient;
    *a = *l = pt;

    return cost;
}

Scott LaVarnway's avatar
Scott LaVarnway committed
555
static int vp8_rdcost_mby(MACROBLOCK *mb)
John Koleszar's avatar
John Koleszar committed
556 557 558 559
{
    int cost = 0;
    int b;
    MACROBLOCKD *x = &mb->e_mbd;
560 561 562 563 564 565
    ENTROPY_CONTEXT_PLANES t_above, t_left;
    ENTROPY_CONTEXT *ta;
    ENTROPY_CONTEXT *tl;

    vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
    vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
John Koleszar's avatar
John Koleszar committed
566

567 568
    ta = (ENTROPY_CONTEXT *)&t_above;
    tl = (ENTROPY_CONTEXT *)&t_left;
John Koleszar's avatar
John Koleszar committed
569 570

    for (b = 0; b < 16; b++)
Scott LaVarnway's avatar
Scott LaVarnway committed
571
        cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_NO_DC,
572
                    ta + vp8_block2above[b], tl + vp8_block2left[b]);
John Koleszar's avatar
John Koleszar committed
573

Scott LaVarnway's avatar
Scott LaVarnway committed
574
    cost += cost_coeffs(mb, x->block + 24, PLANE_TYPE_Y2,
Scott LaVarnway's avatar
Scott LaVarnway committed
575
                ta + vp8_block2above[24], tl + vp8_block2left[24]);
John Koleszar's avatar
John Koleszar committed
576 577 578 579

    return cost;
}

580 581
static void macro_block_yrd( MACROBLOCK *mb,
                             int *Rate,
582
                             int *Distortion)
583 584 585 586 587 588 589 590 591
{
    int b;
    MACROBLOCKD *const x = &mb->e_mbd;
    BLOCK   *const mb_y2 = mb->block + 24;
    BLOCKD *const x_y2  = x->block + 24;
    short *Y2DCPtr = mb_y2->src_diff;
    BLOCK *beptr;
    int d;

592
    vp8_subtract_mby( mb->src_diff, *(mb->block[0].base_src),
593
        mb->block[0].src_stride,  mb->e_mbd.predictor, 16);
594 595 596 597

    // Fdct and building the 2nd order block
    for (beptr = mb->block; beptr < mb->block + 16; beptr += 2)
    {
John Koleszar's avatar
John Koleszar committed
598
        mb->short_fdct8x4(beptr->src_diff, beptr->coeff, 32);
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
        *Y2DCPtr++ = beptr->coeff[0];
        *Y2DCPtr++ = beptr->coeff[16];
    }

    // 2nd order fdct
    mb->short_walsh4x4(mb_y2->src_diff, mb_y2->coeff, 8);

    // Quantization
    for (b = 0; b < 16; b++)
    {
        mb->quantize_b(&mb->block[b], &mb->e_mbd.block[b]);
    }

    // DC predication and Quantization of 2nd Order block
    mb->quantize_b(mb_y2, x_y2);

    // Distortion
616 617
    d = vp8_mbblock_error(mb, 1) << 2;
    d += vp8_block_error(mb_y2->coeff, x_y2->dqcoeff);
618 619 620 621 622 623

    *Distortion = (d >> 4);

    // rate
    *Rate = vp8_rdcost_mby(mb);
}
John Koleszar's avatar
John Koleszar committed
624

625
static void copy_predictor(unsigned char *dst, const unsigned char *predictor)
626
{
627 628 629 630 631 632
    const unsigned int *p = (const unsigned int *)predictor;
    unsigned int *d = (unsigned int *)dst;
    d[0] = p[0];
    d[4] = p[4];
    d[8] = p[8];
    d[12] = p[12];
633
}
634
static int rd_pick_intra4x4block(
John Koleszar's avatar
John Koleszar committed
635 636 637 638 639
    VP8_COMP *cpi,
    MACROBLOCK *x,
    BLOCK *be,
    BLOCKD *b,
    B_PREDICTION_MODE *best_mode,
640
    unsigned int *bmode_costs,
John Koleszar's avatar
John Koleszar committed
641 642 643 644 645 646 647 648
    ENTROPY_CONTEXT *a,
    ENTROPY_CONTEXT *l,

    int *bestrate,
    int *bestratey,
    int *bestdistortion)
{
    B_PREDICTION_MODE mode;
649
    int best_rd = INT_MAX;
John Koleszar's avatar
John Koleszar committed
650 651 652 653 654
    int rate = 0;
    int distortion;

    ENTROPY_CONTEXT ta = *a, tempa = *a;
    ENTROPY_CONTEXT tl = *l, templ = *l;
655 656 657 658 659 660 661
    /*
     * The predictor buffer is a 2d buffer with a stride of 16.  Create
     * a temp buffer that meets the stride requirements, but we are only
     * interested in the left 4x4 block
     * */
    DECLARE_ALIGNED_ARRAY(16, unsigned char,  best_predictor, 16*4);
    DECLARE_ALIGNED_ARRAY(16, short, best_dqcoeff, 16);
Scott LaVarnway's avatar
Scott LaVarnway committed
662 663
    int dst_stride = x->e_mbd.dst.y_stride;
    unsigned char *base_dst = x->e_mbd.dst.y_buffer;
John Koleszar's avatar
John Koleszar committed
664 665 666 667 668 669

    for (mode = B_DC_PRED; mode <= B_HU_PRED; mode++)
    {
        int this_rd;
        int ratey;

670 671
        rate = bmode_costs[mode];

Scott LaVarnway's avatar
Scott LaVarnway committed
672 673
        vp8_intra4x4_predict(base_dst + b->offset, dst_stride, mode,
                             b->predictor, 16);
674
        vp8_subtract_b(be, b, 16);
John Koleszar's avatar
John Koleszar committed
675
        x->short_fdct4x4(be->src_diff, be->coeff, 32);
676
        x->quantize_b(be, b);
John Koleszar's avatar
John Koleszar committed
677 678 679 680

        tempa = ta;
        templ = tl;

Scott LaVarnway's avatar
Scott LaVarnway committed
681
        ratey = cost_coeffs(x, b, PLANE_TYPE_Y_WITH_DC, &tempa, &templ);
John Koleszar's avatar
John Koleszar committed
682
        rate += ratey;
683
        distortion = vp8_block_error(be->coeff, b->dqcoeff) >> 2;
John Koleszar's avatar
John Koleszar committed
684 685 686 687 688 689 690 691 692 693 694 695

        this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);

        if (this_rd < best_rd)
        {
            *bestrate = rate;
            *bestratey = ratey;
            *bestdistortion = distortion;
            best_rd = this_rd;
            *best_mode = mode;
            *a = tempa;
            *l = templ;
696 697
            copy_predictor(best_predictor, b->predictor);
            vpx_memcpy(best_dqcoeff, b->dqcoeff, 32);
John Koleszar's avatar
John Koleszar committed
698 699
        }
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
700
    b->bmi.as_mode = (B_PREDICTION_MODE)(*best_mode);
701

Scott LaVarnway's avatar
Scott LaVarnway committed
702 703
    vp8_short_idct4x4llm(best_dqcoeff, best_predictor, 16, base_dst + b->offset,
                         dst_stride);
John Koleszar's avatar
John Koleszar committed
704

705
    return best_rd;
John Koleszar's avatar
John Koleszar committed
706 707
}

708 709
static int rd_pick_intra4x4mby_modes(VP8_COMP *cpi, MACROBLOCK *mb, int *Rate,
                                     int *rate_y, int *Distortion, int best_rd)
John Koleszar's avatar
John Koleszar committed
710 711 712 713 714 715
{
    MACROBLOCKD *const xd = &mb->e_mbd;
    int i;
    int cost = mb->mbmode_cost [xd->frame_type] [B_PRED];
    int distortion = 0;
    int tot_rate_y = 0;
716
    int64_t total_rd = 0;
717 718 719
    ENTROPY_CONTEXT_PLANES t_above, t_left;
    ENTROPY_CONTEXT *ta;
    ENTROPY_CONTEXT *tl;
720
    unsigned int *bmode_costs;
721 722 723 724 725 726

    vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
    vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));

    ta = (ENTROPY_CONTEXT *)&t_above;
    tl = (ENTROPY_CONTEXT *)&t_left;
John Koleszar's avatar
John Koleszar committed
727

Scott LaVarnway's avatar
Scott LaVarnway committed
728
    intra_prediction_down_copy(xd, xd->dst.y_buffer - xd->dst.y_stride + 16);
John Koleszar's avatar
John Koleszar committed
729

730 731
    bmode_costs = mb->inter_bmode_costs;

John Koleszar's avatar
John Koleszar committed
732 733 734 735 736 737 738
    for (i = 0; i < 16; i++)
    {
        MODE_INFO *const mic = xd->mode_info_context;
        const int mis = xd->mode_info_stride;
        B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
        int UNINITIALIZED_IS_SAFE(r), UNINITIALIZED_IS_SAFE(ry), UNINITIALIZED_IS_SAFE(d);

739 740
        if (mb->e_mbd.frame_type == KEY_FRAME)
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
741 742
            const B_PREDICTION_MODE A = above_block_mode(mic, i, mis);
            const B_PREDICTION_MODE L = left_block_mode(mic, i);
743 744 745 746

            bmode_costs  = mb->bmode_costs[A][L];
        }

747
        total_rd += rd_pick_intra4x4block(
748
            cpi, mb, mb->block + i, xd->block + i, &best_mode, bmode_costs,
749 750
            ta + vp8_block2above[i],
            tl + vp8_block2left[i], &r, &ry, &d);
John Koleszar's avatar
John Koleszar committed
751 752 753 754

        cost += r;
        distortion += d;
        tot_rate_y += ry;
Scott LaVarnway's avatar
Scott LaVarnway committed
755 756

        mic->bmi[i].as_mode = best_mode;
757

758
        if(total_rd >= (int64_t)best_rd)
759
            break;
John Koleszar's avatar
John Koleszar committed
760 761
    }

762
    if(total_rd >= (int64_t)best_rd)
763
        return INT_MAX;
764

John Koleszar's avatar
John Koleszar committed
765
    *Rate = cost;
766
    *rate_y = tot_rate_y;
John Koleszar's avatar
John Koleszar committed
767 768 769 770
    *Distortion = distortion;

    return RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
}
771 772 773 774 775 776 777


static int rd_pick_intra16x16mby_mode(VP8_COMP *cpi,
                                      MACROBLOCK *x,
                                      int *Rate,
                                      int *rate_y,
                                      int *Distortion)
John Koleszar's avatar
John Koleszar committed
778 779 780 781
{
    MB_PREDICTION_MODE mode;
    MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
    int rate, ratey;
782
    int distortion;
John Koleszar's avatar
John Koleszar committed
783
    int best_rd = INT_MAX;
784
    int this_rd;
785
    MACROBLOCKD *xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
786 787 788 789

    //Y Search for 16x16 intra prediction mode
    for (mode = DC_PRED; mode <= TM_PRED; mode++)
    {
790
        xd->mode_info_context->mbmi.mode = mode;
John Koleszar's avatar
John Koleszar committed
791

792 793 794 795 796 797
        vp8_build_intra_predictors_mby_s(xd,
                                         xd->dst.y_buffer - xd->dst.y_stride,
                                         xd->dst.y_buffer - 1,
                                         xd->dst.y_stride,
                                         xd->predictor,
                                         16);
John Koleszar's avatar
John Koleszar committed
798

799
        macro_block_yrd(x, &ratey, &distortion);
800 801
        rate = ratey + x->mbmode_cost[xd->frame_type]
                                     [xd->mode_info_context->mbmi.mode];
John Koleszar's avatar
John Koleszar committed
802 803 804 805 806 807 808 809 810

        this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);

        if (this_rd < best_rd)
        {
            mode_selected = mode;
            best_rd = this_rd;
            *Rate = rate;
            *rate_y = ratey;
811
            *Distortion = distortion;
John Koleszar's avatar
John Koleszar committed
812 813 814
        }
    }

815
    xd->mode_info_context->mbmi.mode = mode_selected;
John Koleszar's avatar
John Koleszar committed
816 817 818 819 820 821 822 823
    return best_rd;
}

static int rd_cost_mbuv(MACROBLOCK *mb)
{
    int b;
    int cost = 0;
    MACROBLOCKD *x = &mb->e_mbd;
824 825 826 827 828 829
    ENTROPY_CONTEXT_PLANES t_above, t_left;
    ENTROPY_CONTEXT *ta;
    ENTROPY_CONTEXT *tl;

    vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
    vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
John Koleszar's avatar
John Koleszar committed
830

831 832
    ta = (ENTROPY_CONTEXT *)&t_above;
    tl = (ENTROPY_CONTEXT *)&t_left;
John Koleszar's avatar
John Koleszar committed
833

Scott LaVarnway's avatar
Scott LaVarnway committed
834 835
    for (b = 16; b < 24; b++)
        cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_UV,
836
                    ta + vp8_block2above[b], tl + vp8_block2left[b]);
John Koleszar's avatar
John Koleszar committed
837 838 839 840 841

    return cost;
}


842 843
static int rd_inter16x16_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate,
                            int *distortion, int fullpixel)
John Koleszar's avatar
John Koleszar committed
844
{
845
    vp8_build_inter16x16_predictors_mbuv(&x->e_mbd);
846
    vp8_subtract_mbuv(x->src_diff,
847 848
        x->src.u_buffer, x->src.v_buffer, x->src.uv_stride,
        &x->e_mbd.predictor[256], &x->e_mbd.predictor[320], 8);
John Koleszar's avatar
John Koleszar committed
849

850 851 852 853
    vp8_transform_mbuv(x);
    vp8_quantize_mbuv(x);

    *rate       = rd_cost_mbuv(x);
854
    *distortion = vp8_mbuverror(x) / 4;
855 856 857 858 859 860 861 862

    return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
}

static int rd_inter4x4_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate,
                          int *distortion, int fullpixel)
{
    vp8_build_inter4x4_predictors_mbuv(&x->e_mbd);
863
    vp8_subtract_mbuv(x->src_diff,
864 865
        x->src.u_buffer, x->src.v_buffer, x->src.uv_stride,
        &x->e_mbd.predictor[256], &x->e_mbd.predictor[320], 8);
866 867 868

    vp8_transform_mbuv(x);
    vp8_quantize_mbuv(x);
John Koleszar's avatar
John Koleszar committed
869 870

    *rate       = rd_cost_mbuv(x);
871
    *distortion = vp8_mbuverror(x) / 4;
John Koleszar's avatar
John Koleszar committed
872

873
    return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
John Koleszar's avatar
John Koleszar committed
874 875
}

876
static void rd_pick_intra_mbuv_mode(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int *distortion)
John Koleszar's avatar
John Koleszar committed
877 878 879 880 881 882
{
    MB_PREDICTION_MODE mode;
    MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
    int best_rd = INT_MAX;
    int UNINITIALIZED_IS_SAFE(d), UNINITIALIZED_IS_SAFE(r);
    int rate_to;
883
    MACROBLOCKD *xd = &x->e_mbd;
John Koleszar's avatar
John Koleszar committed
884 885 886 887 888 889 890

    for (mode = DC_PRED; mode <= TM_PRED; mode++)
    {
        int rate;
        int distortion;
        int this_rd;

891 892 893 894 895 896 897 898 899 900 901 902
        xd->mode_info_context->mbmi.uv_mode = mode;

        vp8_build_intra_predictors_mbuv_s(xd,
                                          xd->dst.u_buffer - xd->dst.uv_stride,
                                          xd->dst.v_buffer - xd->dst.uv_stride,
                                          xd->dst.u_buffer - 1,
                                          xd->dst.v_buffer - 1,
                                          xd->dst.uv_stride,
                                          &xd->predictor[256], &xd->predictor[320],
                                          8);


903
        vp8_subtract_mbuv(x->src_diff,
904
                      x->src.u_buffer, x->src.v_buffer, x->src.uv_stride,
905
                      &xd->predictor[256], &xd->predictor[320], 8);
906 907
        vp8_transform_mbuv(x);
        vp8_quantize_mbuv(x);
John Koleszar's avatar
John Koleszar committed
908 909

        rate_to = rd_cost_mbuv(x);
910
        rate = rate_to + x->intra_uv_mode_cost[xd->frame_type][xd->mode_info_context->mbmi.uv_mode];
John Koleszar's avatar
John Koleszar committed
911

912
        distortion = vp8_mbuverror(x) / 4;
John Koleszar's avatar
John Koleszar committed
913

914
        this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
John Koleszar's avatar
John Koleszar committed
915 916 917 918 919 920 921 922 923 924 925 926 927 928

        if (this_rd < best_rd)
        {
            best_rd = this_rd;
            d = distortion;
            r = rate;
            *rate_tokenonly = rate_to;
            mode_selected = mode;
        }
    }

    *rate = r;
    *distortion = d;

929
    xd->mode_info_context->mbmi.uv_mode = mode_selected;
John Koleszar's avatar
John Koleszar committed
930 931 932 933 934 935 936
}

int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4])
{
    vp8_prob p [VP8_MVREFS-1];
    assert(NEARESTMV <= m  &&  m <= SPLITMV);
    vp8_mv_ref_probs(p, near_mv_ref_ct);
937 938
    return vp8_cost_token(vp8_mv_ref_tree, p,
                          vp8_mv_ref_encoding_array - NEARESTMV + m);
John Koleszar's avatar
John Koleszar committed
939 940
}

Scott LaVarnway's avatar
Scott LaVarnway committed
941
void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv)
John Koleszar's avatar
John Koleszar committed
942
{
943
    x->e_mbd.mode_info_context->mbmi.mode = mb;
Scott LaVarnway's avatar
Scott LaVarnway committed
944
    x->e_mbd.mode_info_context->mbmi.mv.as_int = mv->as_int;
John Koleszar's avatar
John Koleszar committed
945 946 947 948 949 950
}

static int labels2mode(
    MACROBLOCK *x,
    int const *labelings, int which_label,
    B_PREDICTION_MODE this_mode,
Scott LaVarnway's avatar
Scott LaVarnway committed
951
    int_mv *this_mv, int_mv *best_ref_mv,
John Koleszar's avatar
John Koleszar committed
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
    int *mvcost[2]
)
{
    MACROBLOCKD *const xd = & x->e_mbd;
    MODE_INFO *const mic = xd->mode_info_context;
    const int mis = xd->mode_info_stride;

    int cost = 0;
    int thismvcost = 0;

    /* We have to be careful retrieving previously-encoded motion vectors.
       Ones from this macroblock have to be pulled from the BLOCKD array
       as they have not yet made it to the bmi array in our MB_MODE_INFO. */

    int i = 0;

    do
    {
        BLOCKD *const d = xd->block + i;
        const int row = i >> 2,  col = i & 3;

        B_PREDICTION_MODE m;

        if (labelings[i] != which_label)
            continue;

        if (col  &&  labelings[i] == labelings[i-1])
            m = LEFT4X4;
        else if (row  &&  labelings[i] == labelings[i-4])
            m = ABOVE4X4;
        else
        {
            // the only time we should do costing for new motion vector or mode
            // is when we are on a new label  (jbb May 08, 2007)
            switch (m = this_mode)
            {
            case NEW4X4 :
                thismvcost  = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
                break;
            case LEFT4X4:
Scott LaVarnway's avatar
Scott LaVarnway committed
992
                this_mv->as_int = col ? d[-1].bmi.mv.as_int : left_block_mv(mic, i);
John Koleszar's avatar
John Koleszar committed
993 994
                break;
            case ABOVE4X4:
Scott LaVarnway's avatar
Scott LaVarnway committed
995
                this_mv->as_int = row ? d[-4].bmi.mv.as_int : above_block_mv(mic, i, mis);
John Koleszar's avatar
John Koleszar committed
996 997
                break;
            case ZERO4X4:
Scott LaVarnway's avatar
Scott LaVarnway committed
998
                this_mv->as_int = 0;
John Koleszar's avatar
John Koleszar committed
999 1000 1001 1002 1003 1004 1005
                break;
            default:
                break;
            }

            if (m == ABOVE4X4)  // replace above with left if same
            {
Scott LaVarnway's avatar
Scott LaVarnway committed
1006
                int_mv left_mv;
Scott LaVarnway's avatar
Scott LaVarnway committed
1007

Scott LaVarnway's avatar
Scott LaVarnway committed
1008
                left_mv.as_int = col ? d[-1].bmi.mv.as_int :
Scott LaVarnway's avatar
Scott LaVarnway committed
1009
                                        left_block_mv(mic, i);
John Koleszar's avatar
John Koleszar committed
1010

Scott LaVarnway's avatar
Scott LaVarnway committed
1011
                if (left_mv.as_int == this_mv->as_int)
John Koleszar's avatar
John Koleszar committed
1012 1013 1014 1015 1016 1017
                    m = LEFT4X4;
            }

            cost = x->inter_bmode_costs[ m];
        }

Scott LaVarnway's avatar
Scott LaVarnway committed
1018
        d->bmi.mv.as_int = this_mv->as_int;
John Koleszar's avatar
John Koleszar committed
1019

1020 1021 1022
        x->partition_info->bmi[i].mode = m;
        x->partition_info->bmi[i].mv.as_int = this_mv->as_int;

John Koleszar's avatar
John Koleszar committed
1023 1024 1025 1026 1027 1028 1029
    }
    while (++i < 16);

    cost += thismvcost ;
    return cost;
}

1030 1031 1032
static int rdcost_mbsegment_y(MACROBLOCK *mb, const int *labels,
                              int which_label, ENTROPY_CONTEXT *ta,
                              ENTROPY_CONTEXT *tl)
John Koleszar's avatar
John Koleszar committed
1033 1034 1035 1036 1037 1038 1039
{
    int cost = 0;
    int b;
    MACROBLOCKD *x = &mb->e_mbd;

    for (b = 0; b < 16; b++)
        if (labels[ b] == which_label)
Scott LaVarnway's avatar
Scott LaVarnway committed
1040
            cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_WITH_DC,
1041 1042
                                ta + vp8_block2above[b],
                                tl + vp8_block2left[b]);
John Koleszar's avatar
John Koleszar committed
1043 1044 1045 1046

    return cost;

}
1047
static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x, int const *labels, int which_label)
John Koleszar's avatar
John Koleszar committed
1048 1049 1050
{
    int i;
    unsigned int distortion = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
1051 1052 1053
    int pre_stride = x->e_mbd.pre.y_stride;
    unsigned char *base_pre = x->e_mbd.pre.y_buffer;

John Koleszar's avatar
John Koleszar committed
1054 1055 1056 1057 1058 1059 1060 1061

    for (i = 0; i < 16; i++)
    {
        if (labels[i] == which_label)
        {
            BLOCKD *bd = &x->e_mbd.block[i];
            BLOCK *be = &x->block[i];

Scott LaVarnway's avatar
Scott LaVarnway committed
1062
            vp8_build_inter_predictors_b(bd, 16, base_pre, pre_stride, x->e_mbd.subpixel_predict);
1063
            vp8_subtract_b(be, bd, 16);
John Koleszar's avatar
John Koleszar committed
1064
            x->short_fdct4x4(be->src_diff, be->coeff, 32);
John Koleszar's avatar
John Koleszar committed
1065 1066 1067

            // set to 0 no way to account for 2nd order DC so discount
            //be->coeff[0] = 0;
1068
            x->quantize_b(be, bd);
John Koleszar's avatar
John Koleszar committed
1069

1070
            distortion += vp8_block_error(be->coeff, bd->dqcoeff);
John Koleszar's avatar
John Koleszar committed
1071 1072 1073 1074 1075 1076
        }
    }

    return distortion;
}

1077 1078 1079 1080 1081

static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0};


typedef struct
John Koleszar's avatar
John Koleszar committed
1082
{
Scott LaVarnway's avatar
Scott LaVarnway committed
1083 1084
  int_mv *ref_mv;
  int_mv mvp;
1085 1086 1087 1088 1089 1090 1091

  int segment_rd;
  int segment_num;
  int r;
  int d;
  int segment_yrate;
  B_PREDICTION_MODE modes[16];
1092
  int_mv mvs[16];
1093 1094 1095 1096 1097
  unsigned char eobs[16];

  int mvthresh;
  int *mdcounts;

Scott LaVarnway's avatar
Scott LaVarnway committed
1098
  int_mv sv_mvp[4];     // save 4 mvp from 8x8
1099 1100
  int sv_istep[2];  // save 2 initial step_param for 16x8/8x16

1101 1102 1103
} BEST_SEG_INFO;


1104 1105
static void rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x,
                             BEST_SEG_INFO *bsi, unsigned int segmentation)
1106 1107
{
    int i;
John Koleszar's avatar
John Koleszar committed
1108 1109 1110
    int const *labels;
    int br = 0;
    int bd = 0;
1111
    B_PREDICTION_MODE this_mode;
John Koleszar's avatar
John Koleszar committed
1112

1113

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
    int label_count;
    int this_segment_rd = 0;
    int label_mv_thresh;
    int rate = 0;
    int sbr = 0;
    int sbd = 0;
    int segmentyrate = 0;

    vp8_variance_fn_ptr_t *v_fn_ptr;

    ENTROPY_CONTEXT_PLANES t_above, t_left;
    ENTROPY_CONTEXT *ta;
    ENTROPY_CONTEXT *tl;
    ENTROPY_CONTEXT_PLANES t_above_b, t_left_b;
    ENTROPY_CONTEXT *ta_b;
    ENTROPY_CONTEXT *tl_b;
John Koleszar's avatar
John Koleszar committed
1130

1131 1132
    vpx_memcpy(&t_above, x->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
    vpx_memcpy(&t_left, x->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
John Koleszar's avatar
John Koleszar committed
1133

1134 1135 1136 1137 1138 1139 1140
    ta = (ENTROPY_CONTEXT *)&t_above;
    tl = (ENTROPY_CONTEXT *)&t_left;
    ta_b = (ENTROPY_CONTEXT *)&t_above_b;
    tl_b = (ENTROPY_CONTEXT *)&t_left_b;

    br = 0;
    bd = 0;
1141

1142 1143 1144
    v_fn_ptr = &cpi->fn_ptr[segmentation];
    labels = vp8_mbsplits[segmentation];
    label_count = vp8_mbsplit_count[segmentation];
1145

1146 1147 1148 1149 1150 1151 1152 1153 1154
    // 64 makes this threshold really big effectively
    // making it so that we very rarely check mvs on
    // segments.   setting this to 1 would make mv thresh
    // roughly equal to what it is for macroblocks
    label_mv_thresh = 1 * bsi->mvthresh / label_count ;

    // Segmentation method overheads
    rate = vp8_cost_token(vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + segmentation);
    rate += vp8_cost_mv_ref(SPLITMV, bsi->mdcounts);
1155
    this_segment_rd += RDCOST(x->rdmult, x->rddiv, rate, 0);
1156 1157 1158
    br += rate;

    for (i = 0; i < label_count; i++)
John Koleszar's avatar
John Koleszar committed
1159
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
1160
        int_mv mode_mv[B_MODE_COUNT];
1161 1162 1163
        int best_label_rd = INT_MAX;
        B_PREDICTION_MODE mode_selected = ZERO4X4;
        int bestlabelyrate = 0;
John Koleszar's avatar
John Koleszar committed
1164