encodeframe.c 56.2 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
 */


#include "vpx_ports/config.h"
#include "encodemb.h"
#include "encodemv.h"
John Koleszar's avatar
John Koleszar committed
15
#include "vp8/common/common.h"
John Koleszar's avatar
John Koleszar committed
16
#include "onyx_int.h"
John Koleszar's avatar
John Koleszar committed
17
18
19
#include "vp8/common/extend.h"
#include "vp8/common/entropymode.h"
#include "vp8/common/quant_common.h"
20
#include "segmentation.h"
John Koleszar's avatar
John Koleszar committed
21
#include "vp8/common/setupintrarecon.h"
John Koleszar's avatar
John Koleszar committed
22
#include "encodeintra.h"
John Koleszar's avatar
John Koleszar committed
23
#include "vp8/common/reconinter.h"
John Koleszar's avatar
John Koleszar committed
24
25
#include "rdopt.h"
#include "pickinter.h"
John Koleszar's avatar
John Koleszar committed
26
27
#include "vp8/common/findnearmv.h"
#include "vp8/common/reconintra.h"
John Koleszar's avatar
John Koleszar committed
28
#include <stdio.h>
29
#include <math.h>
John Koleszar's avatar
John Koleszar committed
30
#include <limits.h>
John Koleszar's avatar
John Koleszar committed
31
#include "vp8/common/subpixel.h"
John Koleszar's avatar
John Koleszar committed
32
33
#include "vpx_ports/vpx_timer.h"

34
35
36
#if CONFIG_SEGFEATURES
//#define DBG_PRNT_SEGMAP 1
#endif
37

John Koleszar's avatar
John Koleszar committed
38
39
40
41
42
43
44
#if CONFIG_RUNTIME_CPU_DETECT
#define RTCD(x)     &cpi->common.rtcd.x
#define IF_RTCD(x)  (x)
#else
#define RTCD(x)     NULL
#define IF_RTCD(x)  NULL
#endif
45
46
47
48
49
50
51

#if CONFIG_SEGMENTATION
#define SEEK_SEGID 12
#define SEEK_SAMEID 4
#define SEEK_DIFFID 7
#endif

52
53
54
55
56
#ifdef ENC_DEBUG
int enc_debug=0;
int mb_row_debug, mb_col_debug;
#endif

John Koleszar's avatar
John Koleszar committed
57
58
59
60
61
62
63
64
65
66
67
68
69
extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) ;

extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
extern void vp8_auto_select_speed(VP8_COMP *cpi);
extern void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
                                      MACROBLOCK *x,
                                      MB_ROW_COMP *mbr_ei,
                                      int mb_row,
                                      int count);
void vp8_build_block_offsets(MACROBLOCK *x);
void vp8_setup_block_ptrs(MACROBLOCK *x);
int vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t, int recon_yoffset, int recon_uvoffset);
int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t);
70
static void adjust_act_zbin( VP8_COMP *cpi, MACROBLOCK *x );
John Koleszar's avatar
John Koleszar committed
71

72
73


John Koleszar's avatar
John Koleszar committed
74
75
#ifdef MODE_STATS
unsigned int inter_y_modes[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
Yaowu Xu's avatar
Yaowu Xu committed
76
77
78
79
80
81
unsigned int inter_uv_modes[VP8_UV_MODES] = {0, 0, 0, 0};
unsigned int inter_b_modes[15] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned int y_modes[VP8_YMODES] = {0, 0, 0, 0, 0};
unsigned int i8x8_modes[VP8_I8X8_MODES]={0};
unsigned int uv_modes[VP8_UV_MODES] = {0, 0, 0, 0};
unsigned int b_modes[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
John Koleszar's avatar
John Koleszar committed
82
83
84
#endif


85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/* activity_avg must be positive, or flat regions could get a zero weight
 *  (infinite lambda), which confounds analysis.
 * This also avoids the need for divide by zero checks in
 *  vp8_activity_masking().
 */
#define VP8_ACTIVITY_AVG_MIN (64)

/* This is used as a reference when computing the source variance for the
 *  purposes of activity masking.
 * Eventually this should be replaced by custom no-reference routines,
 *  which will be faster.
 */
static const unsigned char VP8_VAR_OFFS[16]=
{
    128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128
};

102

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282

#if CONFIG_T8X8

//INTRA mode transform size
//When all three criteria are off the default is 4x4
//#define INTRA_VARIANCE_ENTROPY_CRITERIA
#define INTRA_WTD_SSE_ENTROPY_CRITERIA
//#define INTRA_TEST_8X8_ONLY
//
//INTER mode transform size
//When all three criteria are off the default is 4x4
//#define INTER_VARIANCE_ENTROPY_CRITERIA
#define INTER_WTD_SSE_ENTROPY_CRITERIA
//#define INTER_TEST_8X8_ONLY

double variance_Block(short *b1, int pitch, int dimension)
{
    short ip[8][8]={{0}};
    short *b = b1;
    int i, j = 0;
    double mean = 0.0, variance = 0.0;
    for (i = 0; i < dimension; i++)
    {
        for (j = 0; j < dimension; j++)
        {
            ip[i][j] = b[j];
            mean += ip[i][j];
        }
        b += pitch;
    }
    mean /= (dimension*dimension);

    for (i = 0; i < dimension; i++)
    {
        for (j = 0; j < dimension; j++)
        {
            variance += (ip[i][j]-mean)*(ip[i][j]-mean);
        }
    }
    variance /= (dimension*dimension);
    return variance;
}

double mean_Block(short *b, int pitch, int dimension)
{
    short ip[8][8]={{0}};
    int i, j = 0;
    double mean = 0;
    for (i = 0; i < dimension; i++)
    {
        for (j = 0; j < dimension; j++)
        {
            ip[i][j] = b[j];
            mean += ip[i][j];
        }
        b += pitch;
    }
    mean /= (dimension*dimension);

    return mean;
}

int SSE_Block(short *b, int pitch, int dimension)
{
    int i, j, sse_block = 0;
    for (i = 0; i < dimension; i++)
    {
        for (j = 0; j < dimension; j++)
        {
            sse_block += b[j]*b[j];
        }
        b += pitch;
    }
   return sse_block;
}

double Compute_Variance_Entropy(MACROBLOCK *x)
{
    double variance_8[4] = {0.0, 0.0, 0.0, 0.0}, sum_var = 0.0, all_entropy = 0.0;
    variance_8[0] = variance_Block(x->block[0].src_diff, 16, 8);
    variance_8[1] = variance_Block(x->block[2].src_diff, 16, 8);
    variance_8[2] = variance_Block(x->block[8].src_diff, 16, 8);
    variance_8[3] = variance_Block(x->block[10].src_diff, 16, 8);
    sum_var = variance_8[0] + variance_8[1] + variance_8[2] + variance_8[3];
    if(sum_var)
    {
      int i;
      for(i = 0; i <4; i++)
      {
        if(variance_8[i])
        {
          variance_8[i] /= sum_var;
          all_entropy -= variance_8[i]*log(variance_8[i]);
        }
      }
    }
    return (all_entropy /log(2));
}

double Compute_Wtd_SSE_SubEntropy(MACROBLOCK *x)
{
    double variance_8[4] = {0.0, 0.0, 0.0, 0.0};
    double entropy_8[4] = {0.0, 0.0, 0.0, 0.0};
    double sse_1, sse_2, sse_3, sse_4, sse_0;
    int i;
    for (i=0;i<3;i+=2)
    {
      sse_0 = SSE_Block(x->block[i].src_diff, 16, 8);
      if(sse_0)
      {
        sse_1 = SSE_Block(x->block[i].src_diff, 16, 4)/sse_0;
        sse_2 = SSE_Block(x->block[i+1].src_diff, 16, 4)/sse_0;
        sse_3 = SSE_Block(x->block[i+4].src_diff, 16, 4)/sse_0;
        sse_4 = SSE_Block(x->block[i+5].src_diff, 16, 4)/sse_0;
        variance_8[i]= variance_Block(x->block[i].src_diff, 16, 8);
        if(sse_1 && sse_2 && sse_3 && sse_4)
        entropy_8[i]= (-sse_1*log(sse_1)
                       -sse_2*log(sse_2)
                       -sse_3*log(sse_3)
                       -sse_4*log(sse_4))/log(2);
      }
    }
    for (i=8;i<11;i+=2)
    {
      if(sse_0)
      {
        sse_0 = SSE_Block(x->block[i].src_diff, 16, 8);
        sse_1 = SSE_Block(x->block[i].src_diff, 16, 4)/sse_0;
        sse_2 = SSE_Block(x->block[i+1].src_diff, 16, 4)/sse_0;
        sse_3 = SSE_Block(x->block[i+4].src_diff, 16, 4)/sse_0;
        sse_4 = SSE_Block(x->block[i+5].src_diff, 16, 4)/sse_0;
        variance_8[i-7]= variance_Block(x->block[i].src_diff, 16, 8);
        if(sse_1 && sse_2 && sse_3 && sse_4)
        entropy_8[i-7]= (-sse_1*log(sse_1)
                         -sse_2*log(sse_2)
                         -sse_3*log(sse_3)
                         -sse_4*log(sse_4))/log(2);
      }
    }
    if(variance_8[0]+variance_8[1]+variance_8[2]+variance_8[3])
      return (entropy_8[0]*variance_8[0]+
              entropy_8[1]*variance_8[1]+
              entropy_8[2]*variance_8[2]+
              entropy_8[3]*variance_8[3])/
             (variance_8[0]+
              variance_8[1]+
              variance_8[2]+
              variance_8[3]);
    else
      return 0;
}

int vp8_8x8_selection_intra(MACROBLOCK *x)
{
#ifdef INTRA_VARIANCE_ENTROPY_CRITERIA
    return (Compute_Variance_Entropy(x) > 1.2);
#elif defined(INTRA_WTD_SSE_ENTROPY_CRITERIA)
    return (Compute_Wtd_SSE_SubEntropy(x) > 1.2);
#elif defined(INTRA_TEST_8X8_ONLY)
    return 1;
#else
    return 0; //when all criteria are off use the default 4x4 only
#endif
}

int vp8_8x8_selection_inter(MACROBLOCK *x)
{
#ifdef INTER_VARIANCE_ENTROPY_CRITERIA
    return (Compute_Variance_Entropy(x) > 1.5);
#elif defined(INTER_WTD_SSE_ENTROPY_CRITERIA)
    return (Compute_Wtd_SSE_SubEntropy(x) > 1.5);
#elif defined(INTER_TEST_8X8_ONLY)
    return 1;
#else
    return 0; //when all criteria are off use the default 4x4 only
#endif
}

#endif

283
// Original activity measure from Tim T's code.
284
static unsigned int tt_activity_measure( VP8_COMP *cpi, MACROBLOCK *x )
285
286
287
288
289
290
291
292
293
294
{
    unsigned int act;
    unsigned int sse;
    /* TODO: This could also be done over smaller areas (8x8), but that would
     *  require extensive changes elsewhere, as lambda is assumed to be fixed
     *  over an entire MB in most of the code.
     * Another option is to compute four 8x8 variances, and pick a single
     *  lambda using a non-linear combination (e.g., the smallest, or second
     *  smallest, etc.).
     */
Yaowu Xu's avatar
Yaowu Xu committed
295
296
297
    act =     VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16)(x->src.y_buffer,
                    x->src.y_stride, VP8_VAR_OFFS, 0, &sse);
    act = act<<4;
298

299
300
301
    /* If the region is flat, lower the activity some more. */
    if (act < 8<<12)
        act = act < 5<<12 ? act : 5<<12;
302

303
304
305
    return act;
}

306
// Stub for alternative experimental activity measures.
307
308
static unsigned int alt_activity_measure( VP8_COMP *cpi,
                                          MACROBLOCK *x, int use_dc_pred )
309
{
Tero Rintaluoma's avatar
Tero Rintaluoma committed
310
    return vp8_encode_intra(cpi,x, use_dc_pred);
311
312
313
314
315
}


// Measure the activity of the current macroblock
// What we measure here is TBD so abstracted to this function
316
317
318
#define ALT_ACT_MEASURE 1
static unsigned int mb_activity_measure( VP8_COMP *cpi, MACROBLOCK *x,
                                  int mb_row, int mb_col)
319
320
321
{
    unsigned int mb_activity;

322
    if  ( ALT_ACT_MEASURE )
323
    {
324
325
326
327
        int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);

        // Or use and alternative.
        mb_activity = alt_activity_measure( cpi, x, use_dc_pred );
328
329
330
    }
    else
    {
331
332
        // Original activity measure from Tim T's code.
        mb_activity = tt_activity_measure( cpi, x );
333
334
    }

335
336
337
    if ( mb_activity < VP8_ACTIVITY_AVG_MIN )
        mb_activity = VP8_ACTIVITY_AVG_MIN;

338
339
340
341
    return mb_activity;
}

// Calculate an "average" mb activity value for the frame
342
#define ACT_MEDIAN 0
343
static void calc_av_activity( VP8_COMP *cpi, int64_t activity_sum )
344
{
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
#if ACT_MEDIAN
    // Find median: Simple n^2 algorithm for experimentation
    {
        unsigned int median;
        unsigned int i,j;
        unsigned int * sortlist;
        unsigned int tmp;

        // Create a list to sort to
        CHECK_MEM_ERROR(sortlist,
                        vpx_calloc(sizeof(unsigned int),
                        cpi->common.MBs));

        // Copy map to sort list
        vpx_memcpy( sortlist, cpi->mb_activity_map,
                    sizeof(unsigned int) * cpi->common.MBs );


        // Ripple each value down to its correct position
        for ( i = 1; i < cpi->common.MBs; i ++ )
        {
            for ( j = i; j > 0; j -- )
            {
                if ( sortlist[j] < sortlist[j-1] )
                {
                    // Swap values
                    tmp = sortlist[j-1];
                    sortlist[j-1] = sortlist[j];
                    sortlist[j] = tmp;
                }
                else
                    break;
            }
        }

        // Even number MBs so estimate median as mean of two either side.
        median = ( 1 + sortlist[cpi->common.MBs >> 1] +
                   sortlist[(cpi->common.MBs >> 1) + 1] ) >> 1;

        cpi->activity_avg = median;

        vpx_free(sortlist);
    }
#else
389
390
    // Simple mean for now
    cpi->activity_avg = (unsigned int)(activity_sum/cpi->common.MBs);
391
392
#endif

393
394
    if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN)
        cpi->activity_avg = VP8_ACTIVITY_AVG_MIN;
395
396
397
398

    // Experimental code: return fixed value normalized for several clips
    if  ( ALT_ACT_MEASURE )
        cpi->activity_avg = 100000;
399
400
}

401
#define USE_ACT_INDEX   0
402
#define OUTPUT_NORM_ACT_STATS   0
403
404
405
406

#if USE_ACT_INDEX
// Calculate and activity index for each mb
static void calc_activity_index( VP8_COMP *cpi, MACROBLOCK *x )
407
408
409
410
{
    VP8_COMMON *const cm = & cpi->common;
    int mb_row, mb_col;

411
412
413
    int64_t act;
    int64_t a;
    int64_t b;
414
415
416

#if OUTPUT_NORM_ACT_STATS
    FILE *f = fopen("norm_act.stt", "a");
417
    fprintf(f, "\n%12d\n", cpi->activity_avg );
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
#endif

    // Reset pointers to start of activity map
    x->mb_activity_ptr = cpi->mb_activity_map;

    // Calculate normalized mb activity number.
    for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
    {
        // for each macroblock col in image
        for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
        {
            // Read activity from the map
            act = *(x->mb_activity_ptr);

            // Calculate a normalized activity number
433
434
            a = act + 4*cpi->activity_avg;
            b = 4*act + cpi->activity_avg;
435
436

            if ( b >= a )
437
                *(x->activity_ptr) = (int)((b + (a>>1))/a) - 1;
438
            else
439
                *(x->activity_ptr) = 1 - (int)((a + (b>>1))/b);
440
441

#if OUTPUT_NORM_ACT_STATS
442
            fprintf(f, " %6d", *(x->mb_activity_ptr));
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
#endif
            // Increment activity map pointers
            x->mb_activity_ptr++;
        }

#if OUTPUT_NORM_ACT_STATS
        fprintf(f, "\n");
#endif

    }

#if OUTPUT_NORM_ACT_STATS
    fclose(f);
#endif

}
459
#endif
460
461
462

// Loop through all MBs. Note activity of each, average activity and
// calculate a normalized activity for each
463
static void build_activity_map( VP8_COMP *cpi )
464
465
{
    MACROBLOCK *const x = & cpi->mb;
466
    MACROBLOCKD *xd = &x->e_mbd;
467
468
    VP8_COMMON *const cm = & cpi->common;

469
470
471
472
473
474
#if ALT_ACT_MEASURE
    YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
    int recon_yoffset;
    int recon_y_stride = new_yv12->y_stride;
#endif

475
476
    int mb_row, mb_col;
    unsigned int mb_activity;
477
    int64_t activity_sum = 0;
478
479
480
481

    // for each macroblock row in image
    for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
    {
482
483
484
485
486
#if ALT_ACT_MEASURE
        // reset above block coeffs
        xd->up_available = (mb_row != 0);
        recon_yoffset = (mb_row * recon_y_stride * 16);
#endif
487
488
489
        // for each macroblock col in image
        for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
        {
490
491
492
493
494
#if ALT_ACT_MEASURE
            xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
            xd->left_available = (mb_col != 0);
            recon_yoffset += 16;
#endif
495
496
497
            //Copy current mb to a buffer
            RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

498
            // measure activity
499
            mb_activity = mb_activity_measure( cpi, x, mb_row, mb_col );
500
501
502
503
504
505
506
507
508
509
510
511
512
513

            // Keep frame sum
            activity_sum += mb_activity;

            // Store MB level activity details.
            *x->mb_activity_ptr = mb_activity;

            // Increment activity map pointer
            x->mb_activity_ptr++;

            // adjust to the next column of source macroblocks
            x->src.y_buffer += 16;
        }

514

515
516
        // adjust to the next row of mbs
        x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
517
518
519
520
521
522
523

#if ALT_ACT_MEASURE
        //extend the recon for intra prediction
        vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16,
                          xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
#endif

524
525
526
527
528
    }

    // Calculate an "average" MB activity
    calc_av_activity(cpi, activity_sum);

529
530
531
532
533
#if USE_ACT_INDEX
    // Calculate an activity index number of each mb
    calc_activity_index( cpi, x );
#endif

534
535
}

536
// Macroblock activity masking
537
538
void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x)
{
539
540
#if USE_ACT_INDEX
    x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
541
542
    x->errorperbit = x->rdmult * 100 /(110 * x->rddiv);
    x->errorperbit += (x->errorperbit==0);
543
#else
544
545
546
    int64_t a;
    int64_t b;
    int64_t act = *(x->mb_activity_ptr);
547
548

    // Apply the masking to the RD multiplier.
549
550
    a = act + (2*cpi->activity_avg);
    b = (2*act) + cpi->activity_avg;
551

552
    x->rdmult = (unsigned int)(((int64_t)x->rdmult*b + (a>>1))/a);
553
554
    x->errorperbit = x->rdmult * 100 /(110 * x->rddiv);
    x->errorperbit += (x->errorperbit==0);
555
#endif
556

557
558
    // Activity based Zbin adjustment
    adjust_act_zbin(cpi, x);
559
}
John Koleszar's avatar
John Koleszar committed
560
561
562
563
564
565
566
567
568
569
570
571
572

static
void encode_mb_row(VP8_COMP *cpi,
                   VP8_COMMON *cm,
                   int mb_row,
                   MACROBLOCK  *x,
                   MACROBLOCKD *xd,
                   TOKENEXTRA **tp,
                   int *segment_counts,
                   int *totalrate)
{
    int recon_yoffset, recon_uvoffset;
    int mb_col;
573
574
575
576
    int ref_fb_idx = cm->lst_fb_idx;
    int dst_fb_idx = cm->new_fb_idx;
    int recon_y_stride = cm->yv12_fb[ref_fb_idx].y_stride;
    int recon_uv_stride = cm->yv12_fb[ref_fb_idx].uv_stride;
577
    int map_index = (mb_row * cpi->common.mb_cols);
578
#if CONFIG_SEGMENTATION
Yaowu Xu's avatar
Yaowu Xu committed
579
    int left_id, above_id;
580
    int sum;
581
#endif
Attila Nagy's avatar
Attila Nagy committed
582
583
584
585
586
587
588
589
590
#if CONFIG_MULTITHREAD
    const int nsync = cpi->mt_sync_range;
    const int rightmost_col = cm->mb_cols - 1;
    volatile const int *last_row_current_mb_col;

    if ((cpi->b_multi_threaded != 0) && (mb_row != 0))
        last_row_current_mb_col = &cpi->mt_current_mb_col[mb_row - 1];
    else
        last_row_current_mb_col = &rightmost_col;
591
#endif
Yaowu Xu's avatar
Yaowu Xu committed
592

John Koleszar's avatar
John Koleszar committed
593
    // reset above block coeffs
594
    xd->above_context = cm->above_context;
John Koleszar's avatar
John Koleszar committed
595
596
597
598
599
600
601
602

    xd->up_available = (mb_row != 0);
    recon_yoffset = (mb_row * recon_y_stride * 16);
    recon_uvoffset = (mb_row * recon_uv_stride * 8);

    cpi->tplist[mb_row].start = *tp;
    //printf("Main mb_row = %d\n", mb_row);

603
604
605
606
607
608
609
610
    // Distance of Mb to the top & bottom edges, specified in 1/8th pel
    // units as they are always compared to values that are in 1/8th pel units
    xd->mb_to_top_edge = -((mb_row * 16) << 3);
    xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;

    // Set up limit values for vertical motion vector components
    // to prevent them extending beyond the UMV borders
    x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
611
    x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16)
612
613
                        + (VP8BORDERINPIXELS - 16);

614
615
616
    // Set the mb activity pointer to the start of the row.
    x->mb_activity_ptr = &cpi->mb_activity_map[map_index];

John Koleszar's avatar
John Koleszar committed
617
618
619
    // for each macroblock col in image
    for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
    {
620
621
622
623
624
625
#ifdef ENC_DEBUG
        //enc_debug = (cpi->count==29 && mb_row==5 && mb_col==0);
        enc_debug = (cpi->count==4 && mb_row==17 && mb_col==13);
        mb_col_debug=mb_col;
        mb_row_debug=mb_row;
#endif
626
627
        // Distance of Mb to the left & right edges, specified in
        // 1/8th pel units as they are always compared to values
628
        // that are in 1/8th pel units
John Koleszar's avatar
John Koleszar committed
629
630
631
        xd->mb_to_left_edge = -((mb_col * 16) << 3);
        xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;

632
633
        // Set up limit values for horizontal motion vector components
        // to prevent them extending beyond the UMV borders
John Koleszar's avatar
John Koleszar committed
634
        x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
635
        x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16)
636
                            + (VP8BORDERINPIXELS - 16);
John Koleszar's avatar
John Koleszar committed
637

638
639
640
        xd->dst.y_buffer = cm->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
        xd->dst.u_buffer = cm->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
        xd->dst.v_buffer = cm->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;
John Koleszar's avatar
John Koleszar committed
641
642
        xd->left_available = (mb_col != 0);

643
644
645
        x->rddiv = cpi->RDDIV;
        x->rdmult = cpi->RDMULT;

646
647
648
        //Copy current mb to a buffer
        RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer, x->src.y_stride, x->thismb, 16);

Attila Nagy's avatar
Attila Nagy committed
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
#if CONFIG_MULTITHREAD
        if ((cpi->b_multi_threaded != 0) && (mb_row != 0))
        {
            if ((mb_col & (nsync - 1)) == 0)
            {
                while (mb_col > (*last_row_current_mb_col - nsync)
                        && (*last_row_current_mb_col) != (cm->mb_cols - 1))
                {
                    x86_pause_hint();
                    thread_sleep(0);
                }
            }
        }
#endif

John Koleszar's avatar
John Koleszar committed
664
        if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
665
            vp8_activity_masking(cpi, x);
666

John Koleszar's avatar
John Koleszar committed
667
668
669
670
671
        // Is segmentation enabled
        // MB level adjutment to quantizer
        if (xd->segmentation_enabled)
        {
            // Code to set segment id in xd->mbmi.segment_id for current MB (with range checking)
Yaowu Xu's avatar
Yaowu Xu committed
672
#if CONFIG_T8X8
673
            // Reset segment_id to 0 or 1 so that the default transform mode is 4x4
674
            if (cpi->segmentation_map[map_index+mb_col] <= 3)
675
                xd->mode_info_context->mbmi.segment_id = cpi->segmentation_map[map_index+mb_col]&1;
Yaowu Xu's avatar
Yaowu Xu committed
676
677
678
679
#else
            if (cpi->segmentation_map[map_index+mb_col] <= 3)
                xd->mode_info_context->mbmi.segment_id = cpi->segmentation_map[map_index+mb_col];
#endif
John Koleszar's avatar
John Koleszar committed
680
            else
681
                xd->mode_info_context->mbmi.segment_id = 0;
John Koleszar's avatar
John Koleszar committed
682
683
684
685

            vp8cx_mb_init_quantizer(cpi, x);
        }
        else
686
            xd->mode_info_context->mbmi.segment_id = 0;         // Set to Segment 0 by default
John Koleszar's avatar
John Koleszar committed
687

688
        x->active_ptr = cpi->active_map + map_index + mb_col;
John Koleszar's avatar
John Koleszar committed
689
690
691
692

        if (cm->frame_type == KEY_FRAME)
        {
            *totalrate += vp8cx_encode_intra_macro_block(cpi, x, tp);
693
694
            //Note the encoder may have changed the segment_id

John Koleszar's avatar
John Koleszar committed
695
#ifdef MODE_STATS
696
            y_modes[xd->mode_info_context->mbmi.mode] ++;
John Koleszar's avatar
John Koleszar committed
697
698
699
700
701
#endif
        }
        else
        {
            *totalrate += vp8cx_encode_inter_macroblock(cpi, x, tp, recon_yoffset, recon_uvoffset);
702
            //Note the encoder may have changed the segment_id
John Koleszar's avatar
John Koleszar committed
703
704

#ifdef MODE_STATS
705
            inter_y_modes[xd->mode_info_context->mbmi.mode] ++;
John Koleszar's avatar
John Koleszar committed
706

707
            if (xd->mode_info_context->mbmi.mode == SPLITMV)
John Koleszar's avatar
John Koleszar committed
708
709
710
            {
                int b;

711
                for (b = 0; b < x->partition_info->count; b++)
John Koleszar's avatar
John Koleszar committed
712
                {
713
                    inter_b_modes[x->partition_info->bmi[b].mode] ++;
John Koleszar's avatar
John Koleszar committed
714
715
716
717
718
                }
            }

#endif

719
            // Count of last ref frame 0,0 usage
720
            if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
John Koleszar's avatar
John Koleszar committed
721
722
                cpi->inter_zz_count ++;

723
724
            // Actions required if segmentation enabled
            if ( xd->segmentation_enabled )
John Koleszar's avatar
John Koleszar committed
725
            {
726
727
728
729
730
731
                // Special case code for cyclic refresh
                // If cyclic update enabled then copy xd->mbmi.segment_id;
                // (which may have been updated based on mode during
                // vp8cx_encode_inter_macroblock()) back into the global
                // segmentation map
                if (cpi->cyclic_refresh_mode_enabled)
John Koleszar's avatar
John Koleszar committed
732
                {
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
                    cpi->segmentation_map[map_index+mb_col] =
                        xd->mode_info_context->mbmi.segment_id;

                    // If the block has been refreshed mark it as clean (the
                    // magnitude of the -ve influences how long it will be
                    // before we consider another refresh):
                    // Else if it was coded (last frame 0,0) and has not
                    // already been refreshed then mark it as a candidate
                    // for cleanup next time (marked 0)
                    // else mark it as dirty (1).
                    if (xd->mode_info_context->mbmi.segment_id)
                        cpi->cyclic_refresh_map[map_index+mb_col] = -1;

                    else if ((xd->mode_info_context->mbmi.mode == ZEROMV) &&
                             (xd->mode_info_context->mbmi.ref_frame ==
                              LAST_FRAME))
                    {
                        if (cpi->cyclic_refresh_map[map_index+mb_col] == 1)
                            cpi->cyclic_refresh_map[map_index+mb_col] = 0;
                    }
                    else
                        cpi->cyclic_refresh_map[map_index+mb_col] = 1;
John Koleszar's avatar
John Koleszar committed
755
756
757
758
759
760
                }
            }
        }

        cpi->tplist[mb_row].stop = *tp;

761
        // Increment pointer into gf usage flags structure.
762
763
764
765
        x->gf_active_ptr++;

        // Increment the activity mask pointers.
        x->mb_activity_ptr++;
John Koleszar's avatar
John Koleszar committed
766

767
#if CONFIG_SEGMENTATION
768
769
        if ((xd->mode_info_context->mbmi.mode == ZEROMV) && (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME))
            xd->mode_info_context->mbmi.segment_id = 0;
770
        else
771
            xd->mode_info_context->mbmi.segment_id = 1;
772
#endif
John Koleszar's avatar
John Koleszar committed
773
774
775
776
777
778
779
780
        // adjust to the next column of macroblocks
        x->src.y_buffer += 16;
        x->src.u_buffer += 8;
        x->src.v_buffer += 8;

        recon_yoffset += 16;
        recon_uvoffset += 8;

781
#if CONFIG_SEGMENTATION
782
783
       //cpi->segmentation_map[mb_row * cm->mb_cols + mb_col] =  xd->mbmi.segment_id;
        if (cm->frame_type == KEY_FRAME)
784
        {
785
            segment_counts[xd->mode_info_context->mbmi.segment_id]++;
786
787
788
        }
        else
        {
789
790
791
792
793
794
            sum = 0;
            if (mb_col != 0)
                sum += (xd->mode_info_context-1)->mbmi.segment_flag;
            if (mb_row != 0)
                sum += (xd->mode_info_context-cm->mb_cols)->mbmi.segment_flag;

795
            if (xd->mode_info_context->mbmi.segment_id == cpi->segmentation_map[(mb_row*cm->mb_cols) + mb_col])
796
797
798
799
800
                xd->mode_info_context->mbmi.segment_flag = 0;
            else
                xd->mode_info_context->mbmi.segment_flag = 1;

            if (xd->mode_info_context->mbmi.segment_flag == 0)
801
            {
802
803
804
805
806
807
808
809
810
                segment_counts[SEEK_SAMEID + sum]++;
                segment_counts[10]++;
            }
            else
            {
                segment_counts[SEEK_DIFFID + sum]++;
                segment_counts[11]++;
                //calculate individual segment ids
                segment_counts[xd->mode_info_context->mbmi.segment_id] ++;
811
812
            }
        }
813
        segment_counts[SEEK_SEGID + xd->mode_info_context->mbmi.segment_id] ++;
814
#else
815
        segment_counts[xd->mode_info_context->mbmi.segment_id] ++;
816
#endif
John Koleszar's avatar
John Koleszar committed
817
818
        // skip to next mb
        xd->mode_info_context++;
819
        x->partition_info++;
John Koleszar's avatar
John Koleszar committed
820

821
        xd->above_context++;
Attila Nagy's avatar
Attila Nagy committed
822
823
824
825
826
827
#if CONFIG_MULTITHREAD
        if (cpi->b_multi_threaded != 0)
        {
            cpi->mt_current_mb_col[mb_row] = mb_col;
        }
#endif
John Koleszar's avatar
John Koleszar committed
828
829
830
831
    }

    //extend the recon for intra prediction
    vp8_extend_mb_row(
832
        &cm->yv12_fb[dst_fb_idx],
John Koleszar's avatar
John Koleszar committed
833
834
835
836
837
838
        xd->dst.y_buffer + 16,
        xd->dst.u_buffer + 8,
        xd->dst.v_buffer + 8);

    // this is to account for the border
    xd->mode_info_context++;
839
    x->partition_info++;
Yaowu Xu's avatar
Yaowu Xu committed
840

Attila Nagy's avatar
Attila Nagy committed
841
842
843
844
845
846
#if CONFIG_MULTITHREAD
    if ((cpi->b_multi_threaded != 0) && (mb_row == cm->mb_rows - 1))
    {
        sem_post(&cpi->h_event_end_encoding); /* signal frame encoding end */
    }
#endif
847
848
849
850


#if CONFIG_SEGFEATURES
// debug output
851
#if DBG_PRNT_SEGMAP
852
853
854
855
856
857
858
859
860
861
    {
        FILE *statsfile;
        statsfile = fopen("segmap2.stt", "a");
        fprintf(statsfile, "\n" );
        fclose(statsfile);
    }
#endif
#endif
}

862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
void init_encode_frame_mb_context(VP8_COMP *cpi)
{
    MACROBLOCK *const x = & cpi->mb;
    VP8_COMMON *const cm = & cpi->common;
    MACROBLOCKD *const xd = & x->e_mbd;

    // GF active flags data structure
    x->gf_active_ptr = (signed char *)cpi->gf_active_flags;

    // Activity map pointer
    x->mb_activity_ptr = cpi->mb_activity_map;

    x->vector_range = 32;

    x->act_zbin_adj = 0;

    x->partition_info = x->pi;

    xd->mode_info_context = cm->mi;
    xd->mode_info_stride = cm->mode_info_stride;

    xd->frame_type = cm->frame_type;

    xd->frames_since_golden = cm->frames_since_golden;
    xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;

    // reset intra mode contexts
    if (cm->frame_type == KEY_FRAME)
        vp8_init_mbmode_probs(cm);

    // Copy data over into macro block data sturctures.
    x->src = * cpi->Source;
    xd->pre = cm->yv12_fb[cm->lst_fb_idx];
    xd->dst = cm->yv12_fb[cm->new_fb_idx];

    // set up frame for intra coded blocks
    vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);

    vp8_build_block_offsets(x);

    vp8_setup_block_dptrs(&x->e_mbd);

    vp8_setup_block_ptrs(x);

    xd->mode_info_context->mbmi.mode = DC_PRED;
    xd->mode_info_context->mbmi.uv_mode = DC_PRED;

    xd->left_context = &cm->left_context;

    vp8_zero(cpi->count_mb_ref_frame_usage)
    vp8_zero(cpi->ymode_count)
    vp8_zero(cpi->uv_mode_count)

    x->mvc = cm->fc.mvc;

    vpx_memset(cm->above_context, 0,
               sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945

    xd->ref_frame_cost[INTRA_FRAME]   = vp8_cost_zero(cpi->prob_intra_coded);

    // Special case treatment when GF and ARF are not sensible options for reference
    if (cpi->ref_frame_flags == VP8_LAST_FLAG)
    {
        xd->ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
                                        + vp8_cost_zero(255);
        xd->ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
                                        + vp8_cost_one(255)
                                        + vp8_cost_zero(128);
        xd->ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
                                        + vp8_cost_one(255)
                                        + vp8_cost_one(128);
    }
    else
    {
        xd->ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
                                        + vp8_cost_zero(cpi->prob_last_coded);
        xd->ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
                                        + vp8_cost_one(cpi->prob_last_coded)
                                        + vp8_cost_zero(cpi->prob_gf_coded);
        xd->ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
                                        + vp8_cost_one(cpi->prob_last_coded)
                                        + vp8_cost_one(cpi->prob_gf_coded);
    }

946
947
948
    xd->fullpixel_mask = 0xffffffff;
    if(cm->full_pixel)
        xd->fullpixel_mask = 0xfffffff8;
949
950
}

John Koleszar's avatar
John Koleszar committed
951
952
953
954
955
956
957
958
void vp8_encode_frame(VP8_COMP *cpi)
{
    int mb_row;
    MACROBLOCK *const x = & cpi->mb;
    VP8_COMMON *const cm = & cpi->common;
    MACROBLOCKD *const xd = & x->e_mbd;

    TOKENEXTRA *tp = cpi->tok;
959

960
#if CONFIG_SEGMENTATION
961
    int segment_counts[MAX_MB_SEGMENTS + SEEK_SEGID];
Yaowu Xu's avatar
Yaowu Xu committed
962
    int prob[3];
963
    int new_cost, original_cost;
964
#else
John Koleszar's avatar
John Koleszar committed
965
    int segment_counts[MAX_MB_SEGMENTS];
966
#endif
John Koleszar's avatar
John Koleszar committed
967
968
    int totalrate;

969
970
971

#if CONFIG_SEGFEATURES
// debug output
Paul Wilkins's avatar
Paul Wilkins committed
972
#if DBG_PRNT_SEGMAP
973
974
975
976
977
978
979
980
981
    {
        FILE *statsfile;
        statsfile = fopen("segmap2.stt", "a");
        fprintf(statsfile, "\n" );
        fclose(statsfile);
    }
#endif
#endif

982
983
984
985
986
987
988
989
990
991
992
    vpx_memset(segment_counts, 0, sizeof(segment_counts));
    totalrate = 0;

    if (cpi->compressor_speed == 2)
    {
        if (cpi->oxcf.cpu_used < 0)
            cpi->Speed = -(cpi->oxcf.cpu_used);
        else
            vp8_auto_select_speed(cpi);
    }

993
994
    // Functions setup for all frame types so we can use MC in AltRef
    if (cm->mcomp_filter_type == SIXTAP)
John Koleszar's avatar
John Koleszar committed
995
    {
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
        xd->subpixel_predict        = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap4x4);
        xd->subpixel_predict8x4     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap8x4);
        xd->subpixel_predict8x8     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap8x8);
        xd->subpixel_predict16x16   = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, sixtap16x16);
    }
    else
    {
        xd->subpixel_predict        = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, bilinear4x4);
        xd->subpixel_predict8x4     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, bilinear8x4);
        xd->subpixel_predict8x8     = SUBPIX_INVOKE(
                                        &cpi->common.rtcd.subpix, bilinear8x8);
        xd->subpixel_predict16x16   = SUBPIX_INVOKE(
                                      &cpi->common.rtcd.subpix, bilinear16x16);
John Koleszar's avatar
John Koleszar committed
1015
1016
    }

1017
    // Reset frame count of inter 0,0 motion vector usage.
John Koleszar's avatar
John Koleszar committed
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    cpi->inter_zz_count = 0;

    vpx_memset(segment_counts, 0, sizeof(segment_counts));

    cpi->prediction_error = 0;
    cpi->intra_error = 0;
    cpi->skip_true_count = 0;
    cpi->skip_false_count = 0;

#if 0
    // Experimental code
1029
    cpi->frame_distortion = 0;
John Koleszar's avatar
John Koleszar committed
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
    cpi->last_mb_distortion = 0;
#endif

    xd->mode_info_context = cm->mi;

    vp8_zero(cpi->MVcount);
    vp8_zero(cpi->coef_counts);

    vp8cx_frame_init_quantizer(cpi);

Paul Wilkins's avatar
Paul Wilkins committed
1040
    vp8_initialize_rd_consts(cpi, cm->base_qindex + cm->y1dc_delta_q);
John Koleszar's avatar
John Koleszar committed
1041
1042
    vp8cx_initialize_me_consts(cpi, cm->base_qindex);

1043
1044
    if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
    {
1045
1046
        // Initialize encode frame context.
        init_encode_frame_mb_context(cpi);
1047

1048
1049
        // Build a frame level activity map
        build_activity_map(cpi);
1050
1051
    }

1052
1053
1054
    // re-initencode frame context.
    init_encode_frame_mb_context(cpi);

John Koleszar's avatar
John Koleszar committed
1055
1056
1057
1058
1059
    {
        struct vpx_usec_timer  emr_timer;
        vpx_usec_timer_start(&emr_timer);

#if CONFIG_MULTITHREAD
1060
1061
        if (cpi->b_multi_threaded)
        {
1062
1063
            int i;

John Koleszar's avatar
John Koleszar committed
1064
1065
            vp8cx_init_mbrthread_data(cpi, x, cpi->mb_row_ei, 1,  cpi->encoding_thread_count);

Attila Nagy's avatar
Attila Nagy committed
1066
            for (i = 0; i < cm->mb_rows; i++)
1067
                cpi->mt_current_mb_col[i] = -1;
John Koleszar's avatar
John Koleszar committed
1068

Attila Nagy's avatar
Attila Nagy committed
1069
1070
1071
1072
            for (i = 0; i < cpi->encoding_thread_count; i++)
            {
                sem_post(&cpi->h_event_start_encoding[i]);
            }
John Koleszar's avatar
John Koleszar committed
1073

Attila Nagy's avatar
Attila Nagy committed
1074
1075
            for (mb_row = 0; mb_row < cm->mb_rows; mb_row += (cpi->encoding_thread_count + 1))
            {
John Koleszar's avatar
John Koleszar committed
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
                vp8_zero(cm->left_context)

                tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);

                encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);

                // adjust to the next row of mbs
                x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
                x->src.u_buffer +=  8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
                x->src.v_buffer +=  8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;

                xd->mode_info_context += xd->mode_info_stride * cpi->encoding_thread_count;
1088
                x->partition_info  += xd->mode_info_stride * cpi->encoding_thread_count;
1089
                x->gf_active_ptr   += cm->mb_cols * cpi->encoding_thread_count;
John Koleszar's avatar
John Koleszar committed
1090
1091
1092

            }

Attila Nagy's avatar
Attila Nagy committed
1093
            sem_wait(&cpi->h_event_end_encoding); /* wait for other threads to finish */
John Koleszar's avatar
John Koleszar committed
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121

            cpi->tok_count = 0;

            for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
            {
                cpi->tok_count += cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start;
            }

            if (xd->segmentation_enabled)
            {
                int i, j;

                if (xd->segmentation_enabled)
                {

                    for (i = 0; i < cpi->encoding_thread_count; i++)
                    {
                        for (j = 0; j < 4; j++)
                            segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
                    }
                }
            }

            for (i = 0; i < cpi->encoding_thread_count; i++)
            {
                totalrate += cpi->mb_row_ei[i].totalrate;
            }

1122
1123
        }
        else
John Koleszar's avatar
John Koleszar committed
1124
#endif
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
        {
            // for each macroblock row in image
            for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
            {

                vp8_zero(cm->left_context)

                encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);

                // adjust to the next row of mbs
                x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
                x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
                x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
            }

            cpi->tok_count = tp - cpi->tok;
John Koleszar's avatar
John Koleszar committed
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152

        }

        vpx_usec_timer_mark(&emr_timer);
        cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);

    }

    // Work out the segment probabilites if segmentation is enabled
    if (xd->segmentation_enabled)
    {
        int tot_count;
1153
        int i;
1154
        int count1,count2,count3,count4;
John Koleszar's avatar
John Koleszar committed
1155
1156
1157

        // Set to defaults
        vpx_memset(xd->mb_segment_tree_probs, 255 , sizeof(xd->mb_segment_tree_probs));
1158
#if CONFIG_SEGMENTATION
1159
1160
1161
1162

        tot_count = segment_counts[12] + segment_counts[13] + segment_counts[14] + segment_counts[15];
        count1 = segment_counts[12] + segment_counts[13];
        count2 = segment_counts[14] + segment_counts[15];
1163
1164

        if (tot_count)
1165
            prob[0] = (count1 * 255) / tot_count;
1166

1167
1168
        if (count1 > 0)
            prob[1] = (segment_counts[12] * 255) /count1;
1169

1170
1171
        if (count2 > 0)
            prob[2] = (segment_counts[14] * 255) /count2;
1172

1173
1174
1175
1176
1177
        if (cm->frame_type != KEY_FRAME)
        {
            tot_count = segment_counts[4] + segment_counts[7];
            if (tot_count)
                xd->mb_segment_tree_probs[3] = (segment_counts[4] * 255)/tot_count;
1178

1179
1180
1181
            tot_count = segment_counts[5] + segment_counts[8];
            if (tot_count)
                xd->mb_segment_tree_probs[4] = (segment_counts[5] * 255)/tot_count;
1182

1183
1184
1185
1186
            tot_count = segment_counts[6] + segment_counts[9];
            if (tot_count)
                xd->mb_segment_tree_probs[5] = (segment_counts[6] * 255)/tot_count;
        }
1187

1188
1189
1190
        tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
        count3 = segment_counts[0] + segment_counts[1];
        count4 = segment_counts[2] + segment_counts[3];
John Koleszar's avatar
John Koleszar committed
1191

1192
1193
        if (tot_count)
            xd->mb_segment_tree_probs[0] = (count3 * 255) / tot_count;
1194

1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
        if (count3 > 0)
            xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) /count3;

        if (count4 > 0)
            xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) /count4;

        for (i = 0; i < MB_FEATURE_TREE_PROBS+3; i++)
        {
            if (xd->mb_segment_tree_probs[i] == 0)
                xd->mb_segment_tree_probs[i] = 1;
        }
1206

1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
        original_cost = count1 * vp8_cost_zero(prob[0]) + count2 * vp8_cost_one(prob[0]);

        if (count1 > 0)
            original_cost += segment_counts[12] * vp8_cost_zero(prob[1]) + segment_counts[13] * vp8_cost_one(prob[1]);

        if (count2 > 0)
            original_cost += segment_counts[14] * vp8_cost_zero(prob[2]) + segment_counts[15] * vp8_cost_one(prob[2]) ;

        new_cost = 0;

        if (cm->frame_type != KEY_FRAME)
        {
            new_cost = segment_counts[4] * vp8_cost_zero(xd->mb_segment_tree_probs[3]) + segment_counts[7] *  vp8_cost_one(xd->mb_segment_tree_probs[3]);

            new_cost += segment_counts[5] * vp8_cost_zero(xd->mb_segment_tree_probs[4]) + segment_counts[8] * vp8_cost_one(xd->mb_segment_tree_probs[4]);

            new_cost += segment_counts[6] * vp8_cost_zero(xd->mb_segment_tree_probs[5]) + segment_counts[9] * vp8_cost_one (xd->mb_segment_tree_probs[5]);
        }
1225
1226

        if (tot_count > 0)
1227
1228
1229
1230
            new_cost += count3 * vp8_cost_zero(xd->mb_segment_tree_probs[0]) + count4 * vp8_cost_one(xd->mb_segment_tree_probs[0]);

        if (count3 > 0)
            new_cost += segment_counts[0] * vp8_cost_zero(xd->mb_segment_tree_probs[1]) + segment_counts[1] * vp8_cost_one(xd->mb_segment_tree_probs[1]);
1231

1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
        if (count4 > 0)
            new_cost += segment_counts[2] * vp8_cost_zero(xd->mb_segment_tree_probs[2]) + segment_counts[3] * vp8_cost_one(xd->mb_segment_tree_probs[2]) ;

        if (new_cost < original_cost)
            xd->temporal_update = 1;
        else
        {
            xd->temporal_update = 0;
            xd->mb_segment_tree_probs[0] = prob[0];
            xd->mb_segment_tree_probs[1] = prob[1];
            xd->mb_segment_tree_probs[2] = prob[2];
        }
1244
#else
John Koleszar's avatar
John Koleszar committed
1245
        tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
1246
1247
        count1 = segment_counts[0] + segment_counts[1];
        count2 = segment_counts[2] + segment_counts[3];
John Koleszar's avatar
John Koleszar committed
1248
1249

        if (tot_count)
1250
            xd->mb_segment_tree_probs[0] = (count1 * 255) / tot_count;
John Koleszar's avatar
John Koleszar committed
1251

1252
1253
        if (count1 > 0)
            xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) /count1;
John Koleszar's avatar
John Koleszar committed
1254

1255
1256
        if (count2 > 0)
            xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) /count2;
John Koleszar's avatar
John Koleszar committed
1257

1258
1259
1260
1261
1262
1263
1264
#endif
        // Zero probabilities not allowed
#if CONFIG_SEGMENTATION
            for (i = 0; i < MB_FEATURE_TREE_PROBS+3; i++)
#else
            for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
#endif
John Koleszar's avatar
John Koleszar committed
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
            {
                if (xd->mb_segment_tree_probs[i] == 0)
                    xd->mb_segment_tree_probs[i] = 1;
            }
    }

    // 256 rate units to the bit
    cpi->projected_frame_size = totalrate >> 8;   // projected_frame_size in units of BYTES

    // Make a note of the percentage MBs coded Intra.
    if (cm->frame_type == KEY_FRAME)
    {
        cpi->this_frame_percent_intra = 100;
    }
    else
    {
        int tot_modes;

        tot_modes = cpi->count_mb_ref_frame_usage[INTRA_FRAME]
                    + cpi->count_mb_ref_frame_usage[LAST_FRAME]
                    + cpi->count_mb_ref_frame_usage[GOLDEN_FRAME]
                    + cpi->count_mb_ref_frame_usage[ALTREF_FRAME];

        if (tot_modes)
            cpi->this_frame_percent_intra = cpi->count_mb_ref_frame_usage[INTRA_FRAME] * 100 / tot_modes;

    }

#if 0
    {
        int cnt = 0;
        int flag[2] = {0, 0};

        for (cnt = 0; cnt < MVPcount; cnt++)
        {
            if (cm->fc.pre_mvc[0][cnt] != cm->fc.mvc[0][cnt])
            {
                flag[0] = 1;
                vpx_memcpy(cm->fc.pre_mvc[0], cm->fc.mvc[0], MVPcount);
                break;
            }
        }

        for (cnt = 0; cnt < MVPcount; cnt++)
        {
            if (cm->fc.pre_mvc[1][cnt] != cm->fc.mvc[1][cnt])
            {
                flag[1] = 1;
                vpx_memcpy(cm->fc.pre_mvc[1], cm->fc.mvc[1], MVPcount);
                break;
            }
        }

        if (flag[0] || flag[1])
1319
            vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
John Koleszar's avatar
John Koleszar committed
1320
1321
1322
    }
#endif

1323
    // Adjust the projected reference frame usage probability numbers to reflect
John Koleszar's avatar
John Koleszar committed
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
    // what we have just seen. This may be usefull when we make multiple itterations
    // of the recode loop rather than continuing to use values from the previous frame.
    if ((cm->frame_type != KEY_FRAME) && !cm->refresh_alt_ref_frame && !cm->refresh_golden_frame)
    {
        const int *const rfct = cpi->count_mb_ref_frame_usage;
        const int rf_intra = rfct[INTRA_FRAME];
        const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];

        if ((rf_intra + rf_inter) > 0)
        {
            cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);

            if (cpi->prob_intra_coded < 1)
                cpi->prob_intra_coded = 1;

            if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
            {
                cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;

                if (cpi->prob_last_coded < 1)
                    cpi->prob_last_coded = 1;

                cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
                                     ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;

                if (cpi->prob_gf_coded < 1)
                    cpi->prob_gf_coded = 1;
            }
        }
1353
1354
1355
1356
1357
1358
1359
1360
1361
#if CONFIG_SEGFEATURES
        else
        {
            // Trap case where cpi->count_mb_ref_frame_usage[] blank.
            cpi->prob_intra_coded = 63;
            cpi->prob_last_coded  = 128;
            cpi->prob_gf_coded    = 128;
        }
#endif
John Koleszar's avatar
John Koleszar committed
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
    }
#if 0
    // Keep record of the total distortion this time around for future use
    cpi->last_frame_distortion = cpi->frame_distortion;
#endif

}
void vp8_setup_block_ptrs(MACROBLOCK *x)
{
    int r, c;
    int i;

    for (r = 0; r < 4; r++)
    {
        for (c = 0; c < 4; c++)
        {
            x->block[r*4+c].src_diff = x->src_diff + r * 4 * 16 + c * 4;
        }
    }

    for (r = 0; r < 2; r++)
    {
        for (c = 0; c < 2; c++)
        {
            x->block[16 + r*2+c].src_diff = x->src_diff + 256 + r * 4 * 8 + c * 4;
        }
    }


    for (r = 0; r < 2; r++)
    {
        for (c = 0; c < 2; c++)
        {
            x->block[20 + r*2+c].src_diff = x->src_diff + 320 + r * 4 * 8 + c * 4;
        }
    }

    x->block[24].src_diff = x->src_diff + 384;


    for (i = 0; i < 25; i++)
    {
        x->block[i].coeff = x->coeff + i * 16;
    }
}

void vp8_build_block_offsets(MACROBLOCK *x)
{
    int block = 0;
    int br, bc;

    vp8_build_block_doffsets(&x->e_mbd);

    // y blocks
1416
    x->thismb_ptr = &x->thismb[0];
John Koleszar's avatar
John Koleszar committed
1417
1418
1419
1420
1421
    for (br = 0; br < 4; br++)
    {
        for (bc = 0; bc < 4; bc++)
        {
            BLOCK *this_block = &x->block[block];
1422
1423
1424
1425
1426
1427
            //this_block->base_src = &x->src.y_buffer;
            //this_block->src_stride = x->src.y_stride;
            //this_block->src = 4 * br * this_block->src_stride + 4 * bc;
            this_block->base_src = &x->thismb_ptr;
            this_block->src_stride = 16;
            this_block->src = 4 * br * 16 + 4 * bc;
John Koleszar's avatar
John Koleszar committed
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
            ++block;
        }
    }

    // u blocks
    for (br = 0; br < 2; br++)
    {
        for (bc = 0; bc < 2; bc++)
        {
            BLOCK *this_block = &x->block[block];
            this_block->base_src = &x->src.u_buffer;
            this_block->src_stride = x->src.uv_stride;
            this_block->src = 4 * br * this_block->src_stride + 4 * bc;
            ++block;
        }
    }

    // v blocks
    for (br = 0; br < 2; br++)
    {
        for (bc = 0; bc < 2; bc++)
        {
            BLOCK *this_block = &x->block[block];
            this_block->base_src = &x->src.v_buffer;
            this_block->src_stride = x->src.uv_stride;
            this_block->src = 4 * br * this_block->src_stride + 4 * bc;
            ++block;
        }
    }
}

static void sum_intra_stats(VP8_COMP *cpi, MACROBLOCK *x)
{
    const MACROBLOCKD *xd = & x->e_mbd;
1462
1463
    const MB_PREDICTION_MODE m = xd->mode_info_context->mbmi