2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include "vpx_ports/config.h"
|
|
|
|
#include "encodemb.h"
|
|
|
|
#include "encodemv.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "onyx_int.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/extend.h"
|
|
|
|
#include "vp8/common/entropymode.h"
|
|
|
|
#include "vp8/common/quant_common.h"
|
2010-08-13 20:50:51 +02:00
|
|
|
#include "segmentation.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/setupintrarecon.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "encodeintra.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/reconinter.h"
|
2012-08-21 02:45:36 +02:00
|
|
|
#include "vp8/common/invtrans.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "rdopt.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/findnearmv.h"
|
|
|
|
#include "vp8/common/reconintra.h"
|
2011-12-22 01:19:09 +01:00
|
|
|
#include "vp8/common/seg_common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include <stdio.h>
|
2011-02-14 23:18:18 +01:00
|
|
|
#include <math.h>
|
2010-05-18 17:58:33 +02:00
|
|
|
#include <limits.h>
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/subpixel.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_ports/vpx_timer.h"
|
2012-01-28 13:20:14 +01:00
|
|
|
#include "vp8/common/pred_common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-14 01:50:03 +02:00
|
|
|
#define DBG_PRNT_SEGMAP 0
|
2012-08-24 16:44:01 +02:00
|
|
|
#if CONFIG_NEW_MVREF
|
|
|
|
#include "vp8/common/mvref_common.h"
|
|
|
|
#endif
|
|
|
|
|
2010-09-24 00:25:33 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#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
|
2010-09-24 00:25:33 +02:00
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef ENC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
int enc_debug = 0;
|
2011-02-14 23:18:18 +01:00
|
|
|
int mb_row_debug, mb_col_debug;
|
|
|
|
#endif
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *xd,
|
2012-08-06 19:51:20 +02:00
|
|
|
TOKENEXTRA **t, int dry_run);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
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);
|
2012-08-20 23:43:34 +02:00
|
|
|
int64_t vp8_rd_pick_inter_mode_sb(VP8_COMP *cpi, MACROBLOCK *x,
|
|
|
|
int recon_yoffset, int recon_uvoffset,
|
|
|
|
int *returnrate, int *returndistortion);
|
|
|
|
extern void vp8cx_pick_mode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x,
|
2012-04-07 01:38:34 +02:00
|
|
|
int recon_yoffset,
|
2012-08-20 23:43:34 +02:00
|
|
|
int recon_uvoffset, int *r, int *d);
|
2010-05-18 17:58:33 +02:00
|
|
|
void vp8_build_block_offsets(MACROBLOCK *x);
|
|
|
|
void vp8_setup_block_ptrs(MACROBLOCK *x);
|
2012-04-07 01:38:34 +02:00
|
|
|
void vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
|
|
|
|
int recon_yoffset, int recon_uvoffset,
|
|
|
|
int output_enabled);
|
2012-08-20 23:43:34 +02:00
|
|
|
void vp8cx_encode_inter_superblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
|
|
|
|
int recon_yoffset, int recon_uvoffset, int mb_col, int mb_row);
|
2012-04-07 01:38:34 +02:00
|
|
|
void vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x,
|
|
|
|
TOKENEXTRA **t, int output_enabled);
|
2012-08-20 23:43:34 +02:00
|
|
|
void vp8cx_encode_intra_super_block(VP8_COMP *cpi,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
TOKENEXTRA **t, int mb_col);
|
2012-07-14 00:21:29 +02:00
|
|
|
static void adjust_act_zbin(VP8_COMP *cpi, MACROBLOCK *x);
|
2012-08-21 02:45:36 +02:00
|
|
|
extern void vp8_stuff_mb_8x8(VP8_COMP *cpi,
|
|
|
|
MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#ifdef MODE_STATS
|
2012-05-15 01:21:01 +02:00
|
|
|
unsigned int inter_y_modes[MB_MODE_COUNT];
|
|
|
|
unsigned int inter_uv_modes[VP8_UV_MODES];
|
|
|
|
unsigned int inter_b_modes[B_MODE_COUNT];
|
|
|
|
unsigned int y_modes[VP8_YMODES];
|
|
|
|
unsigned int i8x8_modes[VP8_I8X8_MODES];
|
|
|
|
unsigned int uv_modes[VP8_UV_MODES];
|
|
|
|
unsigned int uv_modes_y[VP8_YMODES][VP8_UV_MODES];
|
|
|
|
unsigned int b_modes[B_MODE_COUNT];
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2010-10-11 23:37:27 +02:00
|
|
|
/* 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.
|
|
|
|
*/
|
2012-07-14 00:21:29 +02:00
|
|
|
static const unsigned char VP8_VAR_OFFS[16] = {
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
|
2010-10-11 23:37:27 +02:00
|
|
|
};
|
|
|
|
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
// Original activity measure from Tim T's code.
|
2012-07-14 00:21:29 +02:00
|
|
|
static unsigned int tt_activity_measure(VP8_COMP *cpi, MACROBLOCK *x) {
|
|
|
|
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.).
|
|
|
|
*/
|
|
|
|
act = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16)(x->src.y_buffer,
|
|
|
|
x->src.y_stride, VP8_VAR_OFFS, 0, &sse);
|
|
|
|
act = act << 4;
|
|
|
|
|
|
|
|
/* If the region is flat, lower the activity some more. */
|
|
|
|
if (act < 8 << 12)
|
|
|
|
act = act < 5 << 12 ? act : 5 << 12;
|
|
|
|
|
|
|
|
return act;
|
2010-10-11 23:37:27 +02:00
|
|
|
}
|
|
|
|
|
2011-05-12 18:01:55 +02:00
|
|
|
// Stub for alternative experimental activity measures.
|
2012-07-14 00:21:29 +02:00
|
|
|
static unsigned int alt_activity_measure(VP8_COMP *cpi,
|
|
|
|
MACROBLOCK *x, int use_dc_pred) {
|
|
|
|
return vp8_encode_intra(cpi, x, use_dc_pred);
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Measure the activity of the current macroblock
|
|
|
|
// What we measure here is TBD so abstracted to this function
|
2011-06-08 17:00:59 +02:00
|
|
|
#define ALT_ACT_MEASURE 1
|
2012-07-14 00:21:29 +02:00
|
|
|
static unsigned int mb_activity_measure(VP8_COMP *cpi, MACROBLOCK *x,
|
|
|
|
int mb_row, int mb_col) {
|
|
|
|
unsigned int mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (ALT_ACT_MEASURE) {
|
|
|
|
int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Or use and alternative.
|
|
|
|
mb_activity = alt_activity_measure(cpi, x, use_dc_pred);
|
|
|
|
} else {
|
|
|
|
// Original activity measure from Tim T's code.
|
|
|
|
mb_activity = tt_activity_measure(cpi, x);
|
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (mb_activity < VP8_ACTIVITY_AVG_MIN)
|
|
|
|
mb_activity = VP8_ACTIVITY_AVG_MIN;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Calculate an "average" mb activity value for the frame
|
2011-06-08 17:00:59 +02:00
|
|
|
#define ACT_MEDIAN 0
|
2012-07-14 00:21:29 +02:00
|
|
|
static void calc_av_activity(VP8_COMP *cpi, int64_t activity_sum) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ACT_MEDIAN
|
2012-07-14 00:21:29 +02:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
}
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// 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;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->activity_avg = median;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_free(sortlist);
|
|
|
|
}
|
2011-06-08 17:00:59 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
// Simple mean for now
|
|
|
|
cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN)
|
|
|
|
cpi->activity_avg = VP8_ACTIVITY_AVG_MIN;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Experimental code: return fixed value normalized for several clips
|
|
|
|
if (ALT_ACT_MEASURE)
|
|
|
|
cpi->activity_avg = 100000;
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
#define USE_ACT_INDEX 0
|
2011-05-12 18:01:55 +02:00
|
|
|
#define OUTPUT_NORM_ACT_STATS 0
|
2011-06-08 17:00:59 +02:00
|
|
|
|
|
|
|
#if USE_ACT_INDEX
|
|
|
|
// Calculate and activity index for each mb
|
2012-07-14 00:21:29 +02:00
|
|
|
static void calc_activity_index(VP8_COMP *cpi, MACROBLOCK *x) {
|
|
|
|
VP8_COMMON *const cm = & cpi->common;
|
|
|
|
int mb_row, mb_col;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int64_t act;
|
|
|
|
int64_t a;
|
|
|
|
int64_t b;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
FILE *f = fopen("norm_act.stt", "a");
|
|
|
|
fprintf(f, "\n%12d\n", cpi->activity_avg);
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Reset pointers to start of activity map
|
|
|
|
x->mb_activity_ptr = cpi->mb_activity_map;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// 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);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate a normalized activity number
|
|
|
|
a = act + 4 * cpi->activity_avg;
|
|
|
|
b = 4 * act + cpi->activity_avg;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (b >= a)
|
|
|
|
*(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
|
|
|
|
else
|
|
|
|
*(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, " %6d", *(x->mb_activity_ptr));
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// Increment activity map pointers
|
|
|
|
x->mb_activity_ptr++;
|
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "\n");
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(f);
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
// Loop through all MBs. Note activity of each, average activity and
|
|
|
|
// calculate a normalized activity for each
|
2012-07-14 00:21:29 +02:00
|
|
|
static void build_activity_map(VP8_COMP *cpi) {
|
|
|
|
MACROBLOCK *const x = & cpi->mb;
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
VP8_COMMON *const cm = & cpi->common;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ALT_ACT_MEASURE
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
|
|
|
|
int recon_yoffset;
|
|
|
|
int recon_y_stride = new_yv12->y_stride;
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int mb_row, mb_col;
|
|
|
|
unsigned int mb_activity;
|
|
|
|
int64_t activity_sum = 0;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// for each macroblock row in image
|
|
|
|
for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ALT_ACT_MEASURE
|
2012-07-14 00:21:29 +02:00
|
|
|
// reset above block coeffs
|
|
|
|
xd->up_available = (mb_row != 0);
|
|
|
|
recon_yoffset = (mb_row * recon_y_stride * 16);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// for each macroblock col in image
|
|
|
|
for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ALT_ACT_MEASURE
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
|
|
|
|
xd->left_available = (mb_col != 0);
|
|
|
|
recon_yoffset += 16;
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// Copy current mb to a buffer
|
|
|
|
RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
|
|
|
|
x->src.y_stride,
|
|
|
|
x->thismb, 16);
|
2011-06-23 19:54:02 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// measure activity
|
|
|
|
mb_activity = mb_activity_measure(cpi, x, mb_row, mb_col);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Keep frame sum
|
|
|
|
activity_sum += mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Store MB level activity details.
|
|
|
|
*x->mb_activity_ptr = mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Increment activity map pointer
|
|
|
|
x->mb_activity_ptr++;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// adjust to the next column of source macroblocks
|
|
|
|
x->src.y_buffer += 16;
|
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// adjust to the next row of mbs
|
|
|
|
x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
|
|
|
#if ALT_ACT_MEASURE
|
2012-07-14 00:21:29 +02:00
|
|
|
// 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);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate an "average" MB activity
|
|
|
|
calc_av_activity(cpi, activity_sum);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
#if USE_ACT_INDEX
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate an activity index number of each mb
|
|
|
|
calc_activity_index(cpi, x);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
|
|
|
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
// Macroblock activity masking
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_activity_masking(VP8_COMP *cpi, MACROBLOCK *x) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if USE_ACT_INDEX
|
2012-07-14 00:21:29 +02:00
|
|
|
x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
|
|
|
|
x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
|
|
|
|
x->errorperbit += (x->errorperbit == 0);
|
2011-06-08 17:00:59 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
int64_t a;
|
|
|
|
int64_t b;
|
|
|
|
int64_t act = *(x->mb_activity_ptr);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Apply the masking to the RD multiplier.
|
|
|
|
a = act + (2 * cpi->activity_avg);
|
|
|
|
b = (2 * act) + cpi->activity_avg;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->rdmult = (unsigned int)(((int64_t)x->rdmult * b + (a >> 1)) / a);
|
|
|
|
x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
|
|
|
|
x->errorperbit += (x->errorperbit == 0);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Activity based Zbin adjustment
|
|
|
|
adjust_act_zbin(cpi, x);
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void update_state(VP8_COMP *cpi, MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) {
|
|
|
|
int i;
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
MODE_INFO *mi = &ctx->mic;
|
2012-08-14 12:32:29 +02:00
|
|
|
MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
|
2012-07-14 00:21:29 +02:00
|
|
|
int mb_mode = mi->mbmi.mode;
|
|
|
|
int mb_mode_index = ctx->best_mode_index;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert(mb_mode < MB_MODE_COUNT);
|
|
|
|
assert(mb_mode_index < MAX_MODES);
|
|
|
|
assert(mi->mbmi.ref_frame < MAX_REF_FRAMES);
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Restore the coding context of the MB to that that was in place
|
|
|
|
// when the mode was picked for it
|
|
|
|
vpx_memcpy(xd->mode_info_context, mi, sizeof(MODE_INFO));
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (mi->mbmi.encoded_as_sb) {
|
|
|
|
vpx_memcpy(xd->mode_info_context + 1, mi, sizeof(MODE_INFO));
|
|
|
|
vpx_memcpy(xd->mode_info_context + cpi->common.mode_info_stride, mi, sizeof(MODE_INFO));
|
|
|
|
vpx_memcpy(xd->mode_info_context + cpi->common.mode_info_stride + 1, mi, sizeof(MODE_INFO));
|
|
|
|
}
|
|
|
|
#endif
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (mb_mode == B_PRED) {
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
xd->block[i].bmi.as_mode = xd->mode_info_context->bmi[i].as_mode;
|
|
|
|
assert(xd->block[i].bmi.as_mode.first < MB_MODE_COUNT);
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (mb_mode == I8X8_PRED) {
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
xd->block[i].bmi = xd->mode_info_context->bmi[i];
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (mb_mode == SPLITMV) {
|
|
|
|
vpx_memcpy(x->partition_info, &ctx->partition_info,
|
|
|
|
sizeof(PARTITION_INFO));
|
|
|
|
|
2012-08-10 01:07:41 +02:00
|
|
|
mbmi->mv[0].as_int = x->partition_info->bmi[15].mv.as_int;
|
|
|
|
mbmi->mv[1].as_int = x->partition_info->bmi[15].second_mv.as_int;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cpi->common.frame_type == KEY_FRAME) {
|
|
|
|
// Restore the coding modes to that held in the coding context
|
|
|
|
// if (mb_mode == B_PRED)
|
|
|
|
// for (i = 0; i < 16; i++)
|
|
|
|
// {
|
|
|
|
// xd->block[i].bmi.as_mode =
|
|
|
|
// xd->mode_info_context->bmi[i].as_mode;
|
|
|
|
// assert(xd->mode_info_context->bmi[i].as_mode < MB_MODE_COUNT);
|
|
|
|
// }
|
2012-07-03 22:57:27 +02:00
|
|
|
#if CONFIG_INTERNAL_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int kf_mode_index[] = {
|
|
|
|
THR_DC /*DC_PRED*/,
|
|
|
|
THR_V_PRED /*V_PRED*/,
|
|
|
|
THR_H_PRED /*H_PRED*/,
|
|
|
|
THR_D45_PRED /*D45_PRED*/,
|
|
|
|
THR_D135_PRED /*D135_PRED*/,
|
|
|
|
THR_D117_PRED /*D117_PRED*/,
|
|
|
|
THR_D153_PRED /*D153_PRED*/,
|
|
|
|
THR_D27_PRED /*D27_PRED*/,
|
|
|
|
THR_D63_PRED /*D63_PRED*/,
|
|
|
|
THR_TM /*TM_PRED*/,
|
|
|
|
THR_I8X8_PRED /*I8X8_PRED*/,
|
|
|
|
THR_B_PRED /*B_PRED*/,
|
|
|
|
};
|
|
|
|
cpi->mode_chosen_counts[kf_mode_index[mb_mode]]++;
|
2012-07-03 22:57:27 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
// Reduce the activation RD thresholds for the best choice mode
|
|
|
|
if ((cpi->rd_baseline_thresh[mb_mode_index] > 0) &&
|
|
|
|
(cpi->rd_baseline_thresh[mb_mode_index] < (INT_MAX >> 2)))
|
|
|
|
{
|
|
|
|
int best_adjustment = (cpi->rd_thresh_mult[mb_mode_index] >> 2);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->rd_thresh_mult[mb_mode_index] =
|
|
|
|
(cpi->rd_thresh_mult[mb_mode_index]
|
|
|
|
>= (MIN_THRESHMULT + best_adjustment)) ?
|
|
|
|
cpi->rd_thresh_mult[mb_mode_index] - best_adjustment :
|
|
|
|
MIN_THRESHMULT;
|
|
|
|
cpi->rd_threshes[mb_mode_index] =
|
|
|
|
(cpi->rd_baseline_thresh[mb_mode_index] >> 7)
|
|
|
|
* cpi->rd_thresh_mult[mb_mode_index];
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
*/
|
|
|
|
// Note how often each mode chosen as best
|
|
|
|
cpi->mode_chosen_counts[mb_mode_index]++;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
rd_update_mvcount(cpi, x, &ctx->best_ref_mv, &ctx->second_best_ref_mv);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->prediction_error += ctx->distortion;
|
|
|
|
cpi->intra_error += ctx->intra_error;
|
2012-08-20 23:43:34 +02:00
|
|
|
|
|
|
|
cpi->rd_comp_pred_diff[0] += ctx->single_pred_diff;
|
|
|
|
cpi->rd_comp_pred_diff[1] += ctx->comp_pred_diff;
|
|
|
|
cpi->rd_comp_pred_diff[2] += ctx->hybrid_pred_diff;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void pick_mb_modes(VP8_COMP *cpi,
|
|
|
|
VP8_COMMON *cm,
|
|
|
|
int mb_row,
|
|
|
|
int mb_col,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
2012-08-20 23:43:34 +02:00
|
|
|
int *totalrate,
|
|
|
|
int *totaldist) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int i;
|
|
|
|
int map_index;
|
|
|
|
int recon_yoffset, recon_uvoffset;
|
|
|
|
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;
|
|
|
|
ENTROPY_CONTEXT_PLANES left_context[2];
|
|
|
|
ENTROPY_CONTEXT_PLANES above_context[2];
|
|
|
|
ENTROPY_CONTEXT_PLANES *initial_above_context_ptr = cm->above_context
|
|
|
|
+ mb_col;
|
|
|
|
|
|
|
|
// Offsets to move pointers from MB to MB within a SB in raster order
|
|
|
|
int row_delta[4] = { 0, +1, 0, -1};
|
|
|
|
int col_delta[4] = { +1, -1, +1, +1};
|
|
|
|
|
|
|
|
/* Function should not modify L & A contexts; save and restore on exit */
|
|
|
|
vpx_memcpy(left_context,
|
2012-08-20 23:43:34 +02:00
|
|
|
cm->left_context,
|
2012-07-14 00:21:29 +02:00
|
|
|
sizeof(left_context));
|
|
|
|
vpx_memcpy(above_context,
|
|
|
|
initial_above_context_ptr,
|
|
|
|
sizeof(above_context));
|
|
|
|
|
|
|
|
/* Encode MBs in raster order within the SB */
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int dy = row_delta[i];
|
|
|
|
int dx = col_delta[i];
|
|
|
|
int offset_unextended = dy * cm->mb_cols + dx;
|
|
|
|
int offset_extended = dy * xd->mode_info_stride + dx;
|
2012-08-10 15:12:43 +02:00
|
|
|
MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// TODO Many of the index items here can be computed more efficiently!
|
|
|
|
|
|
|
|
if ((mb_row >= cm->mb_rows) || (mb_col >= cm->mb_cols)) {
|
|
|
|
// MB lies outside frame, move on
|
|
|
|
mb_row += dy;
|
|
|
|
mb_col += dx;
|
|
|
|
|
|
|
|
// Update pointers
|
|
|
|
x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
|
|
|
|
x->src.u_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
x->src.v_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
|
|
|
|
x->gf_active_ptr += offset_unextended;
|
|
|
|
x->partition_info += offset_extended;
|
|
|
|
xd->mode_info_context += offset_extended;
|
|
|
|
xd->prev_mode_info_context += offset_extended;
|
2012-04-07 01:38:34 +02:00
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
|
|
|
|
(xd->mode_info_context - cpi->common.mip));
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
continue;
|
|
|
|
}
|
2012-05-15 02:39:42 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Index of the MB in the SB 0..3
|
|
|
|
xd->mb_index = i;
|
|
|
|
|
|
|
|
map_index = (mb_row * cpi->common.mb_cols) + mb_col;
|
|
|
|
x->mb_activity_ptr = &cpi->mb_activity_map[map_index];
|
|
|
|
|
|
|
|
// set above context pointer
|
|
|
|
xd->above_context = cm->above_context + mb_col;
|
|
|
|
|
|
|
|
// Restore the appropriate left context depending on which
|
|
|
|
// row in the SB the MB is situated
|
2012-08-20 23:43:34 +02:00
|
|
|
xd->left_context = cm->left_context + (i >> 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Set up distance of MB to edge of frame in 1/8th pel units
|
|
|
|
xd->mb_to_top_edge = -((mb_row * 16) << 3);
|
|
|
|
xd->mb_to_left_edge = -((mb_col * 16) << 3);
|
|
|
|
xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
|
|
|
|
xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
|
|
|
|
|
|
|
|
// Set up limit values for MV components to prevent them from
|
|
|
|
// extending beyond the UMV borders assuming 16x16 block size
|
|
|
|
x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
|
|
|
|
x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
|
|
|
|
|
|
|
|
xd->up_available = (mb_row != 0);
|
|
|
|
xd->left_available = (mb_col != 0);
|
|
|
|
|
|
|
|
recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
|
|
|
|
recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
// Copy current MB to a work buffer
|
|
|
|
RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
|
|
|
|
x->src.y_stride,
|
|
|
|
x->thismb, 16);
|
|
|
|
|
|
|
|
x->rddiv = cpi->RDDIV;
|
|
|
|
x->rdmult = cpi->RDMULT;
|
|
|
|
|
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
|
|
|
|
vp8_activity_masking(cpi, x);
|
|
|
|
|
|
|
|
// Is segmentation enabled
|
|
|
|
if (xd->segmentation_enabled) {
|
|
|
|
// Code to set segment id in xd->mbmi.segment_id
|
2012-08-20 23:43:34 +02:00
|
|
|
if (xd->update_mb_segmentation_map)
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->segment_id = cpi->segmentation_map[map_index];
|
2012-07-14 00:21:29 +02:00
|
|
|
else
|
2012-08-20 23:43:34 +02:00
|
|
|
mbmi->segment_id = cm->last_frame_seg_map[map_index];
|
|
|
|
if (mbmi->segment_id > 3)
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->segment_id = 0;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
vp8cx_mb_init_quantizer(cpi, x);
|
|
|
|
} else
|
|
|
|
// Set to Segment 0 by default
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->segment_id = 0;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
x->active_ptr = cpi->active_map + map_index;
|
|
|
|
|
|
|
|
/* force 4x4 transform for mode selection */
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->txfm_size = TX_4X4; // TODO IS this right??
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
xd->mode_info_context->mbmi.encoded_as_sb = 0;
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->update_context = 0; // TODO Do we need this now??
|
|
|
|
|
|
|
|
// Find best coding mode & reconstruct the MB so it is available
|
|
|
|
// as a predictor for MBs that follow in the SB
|
|
|
|
if (cm->frame_type == KEY_FRAME) {
|
2012-08-20 23:43:34 +02:00
|
|
|
int r, d;
|
|
|
|
vp8_rd_pick_intra_mode(cpi, x, &r, &d);
|
|
|
|
*totalrate += r;
|
|
|
|
*totaldist += d;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Dummy encode, do not do the tokenization
|
|
|
|
vp8cx_encode_intra_macro_block(cpi, x, tp, 0);
|
|
|
|
// Note the encoder may have changed the segment_id
|
2012-08-20 23:43:34 +02:00
|
|
|
|
|
|
|
// Save the coding context
|
|
|
|
vpx_memcpy(&x->mb_context[i].mic, xd->mode_info_context,
|
|
|
|
sizeof(MODE_INFO));
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-20 23:43:34 +02:00
|
|
|
int seg_id, r, d;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
|
|
|
|
!segfeature_active(xd, 0, SEG_LVL_REF_FRAME) &&
|
|
|
|
segfeature_active(xd, 1, SEG_LVL_REF_FRAME) &&
|
|
|
|
check_segref(xd, 1, INTRA_FRAME) +
|
|
|
|
check_segref(xd, 1, LAST_FRAME) +
|
|
|
|
check_segref(xd, 1, GOLDEN_FRAME) +
|
|
|
|
check_segref(xd, 1, ALTREF_FRAME) == 1) {
|
|
|
|
cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
|
|
|
|
} else {
|
|
|
|
cpi->seg0_progress = (((mb_col & ~1) * 2 + (mb_row & ~1) * cm->mb_cols + i) << 16) / cm->MBs;
|
|
|
|
}
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
vp8cx_pick_mode_inter_macroblock(cpi, x, recon_yoffset,
|
|
|
|
recon_uvoffset, &r, &d);
|
|
|
|
*totalrate += r;
|
|
|
|
*totaldist += d;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Dummy encode, do not do the tokenization
|
|
|
|
vp8cx_encode_inter_macroblock(cpi, x, tp,
|
|
|
|
recon_yoffset, recon_uvoffset, 0);
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
seg_id = mbmi->segment_id;
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->mb.e_mbd.segmentation_enabled && seg_id == 0) {
|
|
|
|
cpi->seg0_idx++;
|
|
|
|
}
|
|
|
|
if (!xd->segmentation_enabled ||
|
|
|
|
!segfeature_active(xd, seg_id, SEG_LVL_REF_FRAME) ||
|
|
|
|
check_segref(xd, seg_id, INTRA_FRAME) +
|
|
|
|
check_segref(xd, seg_id, LAST_FRAME) +
|
|
|
|
check_segref(xd, seg_id, GOLDEN_FRAME) +
|
|
|
|
check_segref(xd, seg_id, ALTREF_FRAME) > 1) {
|
|
|
|
// Get the prediction context and status
|
|
|
|
int pred_flag = get_pred_flag(xd, PRED_REF);
|
|
|
|
int pred_context = get_pred_context(cm, xd, PRED_REF);
|
|
|
|
|
|
|
|
// Count prediction success
|
|
|
|
cpi->ref_pred_count[pred_context][pred_flag]++;
|
|
|
|
}
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Next MB
|
|
|
|
mb_row += dy;
|
|
|
|
mb_col += dx;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
|
|
|
|
x->src.u_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
x->src.v_buffer += 8 * (dx + dy * x->src.uv_stride);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->gf_active_ptr += offset_unextended;
|
|
|
|
x->partition_info += offset_extended;
|
|
|
|
xd->mode_info_context += offset_extended;
|
|
|
|
xd->prev_mode_info_context += offset_extended;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
|
|
|
|
(xd->mode_info_context - cpi->common.mip));
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore L & A coding context to those in place on entry */
|
2012-08-20 23:43:34 +02:00
|
|
|
vpx_memcpy(cm->left_context,
|
2012-07-14 00:21:29 +02:00
|
|
|
left_context,
|
|
|
|
sizeof(left_context));
|
|
|
|
vpx_memcpy(initial_above_context_ptr,
|
|
|
|
above_context,
|
|
|
|
sizeof(above_context));
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
static void pick_sb_modes (VP8_COMP *cpi,
|
|
|
|
VP8_COMMON *cm,
|
|
|
|
int mb_row,
|
|
|
|
int mb_col,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int *totalrate,
|
|
|
|
int *totaldist)
|
|
|
|
{
|
|
|
|
int map_index;
|
|
|
|
int recon_yoffset, recon_uvoffset;
|
|
|
|
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;
|
|
|
|
ENTROPY_CONTEXT_PLANES left_context[2];
|
|
|
|
ENTROPY_CONTEXT_PLANES above_context[2];
|
|
|
|
ENTROPY_CONTEXT_PLANES *initial_above_context_ptr = cm->above_context
|
|
|
|
+ mb_col;
|
|
|
|
|
|
|
|
/* Function should not modify L & A contexts; save and restore on exit */
|
|
|
|
vpx_memcpy (left_context,
|
|
|
|
cm->left_context,
|
|
|
|
sizeof(left_context));
|
|
|
|
vpx_memcpy (above_context,
|
|
|
|
initial_above_context_ptr,
|
|
|
|
sizeof(above_context));
|
|
|
|
|
|
|
|
map_index = (mb_row * cpi->common.mb_cols) + mb_col;
|
|
|
|
x->mb_activity_ptr = &cpi->mb_activity_map[map_index];
|
|
|
|
|
|
|
|
/* set above context pointer */
|
|
|
|
xd->above_context = cm->above_context + mb_col;
|
|
|
|
|
|
|
|
/* Restore the appropriate left context depending on which
|
|
|
|
* row in the SB the MB is situated */
|
|
|
|
xd->left_context = cm->left_context;
|
|
|
|
|
|
|
|
// Set up distance of MB to edge of frame in 1/8th pel units
|
|
|
|
xd->mb_to_top_edge = -((mb_row * 16) << 3);
|
|
|
|
xd->mb_to_left_edge = -((mb_col * 16) << 3);
|
|
|
|
xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
|
|
|
|
xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
|
|
|
|
|
|
|
|
/* Set up limit values for MV components to prevent them from
|
|
|
|
* extending beyond the UMV borders assuming 16x16 block size */
|
|
|
|
x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
|
|
|
|
x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
|
|
|
|
|
|
|
|
xd->up_available = (mb_row != 0);
|
|
|
|
xd->left_available = (mb_col != 0);
|
|
|
|
|
|
|
|
recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
|
|
|
|
recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);
|
|
|
|
|
|
|
|
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;
|
|
|
|
#if 0 // FIXME
|
|
|
|
/* Copy current MB to a work buffer */
|
|
|
|
RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
|
|
|
|
x->src.y_stride,
|
|
|
|
x->thismb, 16);
|
|
|
|
#endif
|
|
|
|
x->rddiv = cpi->RDDIV;
|
|
|
|
x->rdmult = cpi->RDMULT;
|
|
|
|
if(cpi->oxcf.tuning == VP8_TUNE_SSIM)
|
|
|
|
vp8_activity_masking(cpi, x);
|
|
|
|
/* Is segmentation enabled */
|
|
|
|
if (xd->segmentation_enabled)
|
|
|
|
{
|
|
|
|
/* Code to set segment id in xd->mbmi.segment_id */
|
|
|
|
if (xd->update_mb_segmentation_map)
|
|
|
|
xd->mode_info_context->mbmi.segment_id =
|
|
|
|
cpi->segmentation_map[map_index] &&
|
|
|
|
cpi->segmentation_map[map_index + 1] &&
|
|
|
|
cpi->segmentation_map[map_index + cm->mb_cols] &&
|
|
|
|
cpi->segmentation_map[map_index + cm->mb_cols + 1];
|
|
|
|
else
|
|
|
|
xd->mode_info_context->mbmi.segment_id =
|
|
|
|
cm->last_frame_seg_map[map_index] &&
|
|
|
|
cm->last_frame_seg_map[map_index + 1] &&
|
|
|
|
cm->last_frame_seg_map[map_index + cm->mb_cols] &&
|
|
|
|
cm->last_frame_seg_map[map_index + cm->mb_cols + 1];
|
|
|
|
if (xd->mode_info_context->mbmi.segment_id > 3)
|
|
|
|
xd->mode_info_context->mbmi.segment_id = 0;
|
|
|
|
|
|
|
|
vp8cx_mb_init_quantizer(cpi, x);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* Set to Segment 0 by default */
|
|
|
|
xd->mode_info_context->mbmi.segment_id = 0;
|
|
|
|
|
|
|
|
x->active_ptr = cpi->active_map + map_index;
|
|
|
|
|
|
|
|
cpi->update_context = 0; // TODO Do we need this now??
|
|
|
|
|
|
|
|
/* Find best coding mode & reconstruct the MB so it is available
|
|
|
|
* as a predictor for MBs that follow in the SB */
|
|
|
|
if (cm->frame_type == KEY_FRAME)
|
|
|
|
{
|
|
|
|
vp8_rd_pick_intra_mode_sb(cpi, x,
|
|
|
|
totalrate,
|
|
|
|
totaldist);
|
|
|
|
|
|
|
|
/* Save the coding context */
|
|
|
|
vpx_memcpy(&x->sb_context[0].mic, xd->mode_info_context,
|
|
|
|
sizeof(MODE_INFO));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
|
|
|
|
!segfeature_active( xd, 0, SEG_LVL_REF_FRAME ) &&
|
|
|
|
segfeature_active( xd, 1, SEG_LVL_REF_FRAME ) &&
|
|
|
|
check_segref(xd, 1, INTRA_FRAME) +
|
|
|
|
check_segref(xd, 1, LAST_FRAME) +
|
|
|
|
check_segref(xd, 1, GOLDEN_FRAME) +
|
|
|
|
check_segref(xd, 1, ALTREF_FRAME) == 1)
|
|
|
|
{
|
|
|
|
cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cpi->seg0_progress =
|
|
|
|
(((mb_col & ~1) * 2 + (mb_row & ~1) * cm->mb_cols) << 16) / cm->MBs;
|
|
|
|
}
|
|
|
|
|
|
|
|
vp8_rd_pick_inter_mode_sb(cpi, x,
|
|
|
|
recon_yoffset,
|
|
|
|
recon_uvoffset,
|
|
|
|
totalrate,
|
|
|
|
totaldist);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore L & A coding context to those in place on entry */
|
|
|
|
vpx_memcpy (cm->left_context,
|
|
|
|
left_context,
|
|
|
|
sizeof(left_context));
|
|
|
|
vpx_memcpy (initial_above_context_ptr,
|
|
|
|
above_context,
|
|
|
|
sizeof(above_context));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void encode_sb(VP8_COMP *cpi,
|
|
|
|
VP8_COMMON *cm,
|
|
|
|
int mbrow,
|
|
|
|
int mbcol,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp) {
|
|
|
|
int i;
|
|
|
|
int map_index;
|
|
|
|
int mb_row, mb_col;
|
|
|
|
int recon_yoffset, recon_uvoffset;
|
|
|
|
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;
|
|
|
|
int row_delta[4] = { 0, +1, 0, -1};
|
|
|
|
int col_delta[4] = { +1, -1, +1, +1};
|
|
|
|
|
|
|
|
mb_row = mbrow;
|
|
|
|
mb_col = mbcol;
|
|
|
|
|
|
|
|
/* Encode MBs in raster order within the SB */
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int dy = row_delta[i];
|
|
|
|
int dx = col_delta[i];
|
|
|
|
int offset_extended = dy * xd->mode_info_stride + dx;
|
|
|
|
int offset_unextended = dy * cm->mb_cols + dx;
|
2012-08-10 15:12:43 +02:00
|
|
|
MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if ((mb_row >= cm->mb_rows) || (mb_col >= cm->mb_cols)) {
|
|
|
|
// MB lies outside frame, move on
|
|
|
|
mb_row += dy;
|
|
|
|
mb_col += dx;
|
|
|
|
|
|
|
|
x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
|
|
|
|
x->src.u_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
x->src.v_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
|
|
|
|
x->gf_active_ptr += offset_unextended;
|
|
|
|
x->partition_info += offset_extended;
|
|
|
|
xd->mode_info_context += offset_extended;
|
|
|
|
xd->prev_mode_info_context += offset_extended;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
|
|
|
|
(xd->mode_info_context - cpi->common.mip));
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
continue;
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mb_index = i;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef ENC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
enc_debug = (cpi->common.current_video_frame == 0 &&
|
|
|
|
mb_row == 0 && mb_col == 0);
|
|
|
|
mb_col_debug = mb_col;
|
|
|
|
mb_row_debug = mb_row;
|
2011-02-14 23:18:18 +01:00
|
|
|
#endif
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Restore MB state to that when it was picked
|
2012-04-07 01:38:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
2012-08-20 23:43:34 +02:00
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
2012-07-14 00:21:29 +02:00
|
|
|
update_state(cpi, x, &x->sb_context[i]);
|
2012-08-20 23:43:34 +02:00
|
|
|
cpi->sb_count++;
|
|
|
|
} else
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
update_state(cpi, x, &x->mb_context[i]);
|
|
|
|
|
|
|
|
map_index = (mb_row * cpi->common.mb_cols) + mb_col;
|
|
|
|
x->mb_activity_ptr = &cpi->mb_activity_map[map_index];
|
|
|
|
|
|
|
|
// reset above block coeffs
|
|
|
|
xd->above_context = cm->above_context + mb_col;
|
2012-08-20 23:43:34 +02:00
|
|
|
xd->left_context = cm->left_context + (i >> 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Set up distance of MB to edge of the frame in 1/8th pel units
|
|
|
|
xd->mb_to_top_edge = -((mb_row * 16) << 3);
|
|
|
|
xd->mb_to_left_edge = -((mb_col * 16) << 3);
|
|
|
|
xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
|
|
|
|
xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
|
|
|
|
|
2012-04-07 01:38:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
2012-08-20 23:43:34 +02:00
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
// Set up limit values for MV components to prevent them from
|
|
|
|
// extending beyond the UMV borders assuming 32x32 block size
|
|
|
|
x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
|
|
|
|
x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 32 - INTERP_EXTEND));
|
|
|
|
} else {
|
|
|
|
#endif
|
|
|
|
// Set up limit values for MV components to prevent them from
|
|
|
|
// extending beyond the UMV borders assuming 16x16 block size
|
|
|
|
x->mv_row_min = -((mb_row * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_col_min = -((mb_col * 16) + VP8BORDERINPIXELS - INTERP_EXTEND);
|
|
|
|
x->mv_row_max = ((cm->mb_rows - mb_row) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
|
|
|
|
x->mv_col_max = ((cm->mb_cols - mb_col) * 16 +
|
|
|
|
(VP8BORDERINPIXELS - 16 - INTERP_EXTEND));
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->up_available = (mb_row != 0);
|
|
|
|
xd->left_available = (mb_col != 0);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
|
|
|
|
recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Copy current MB to a work buffer
|
|
|
|
RECON_INVOKE(&xd->rtcd->recon, copy16x16)(x->src.y_buffer,
|
|
|
|
x->src.y_stride,
|
|
|
|
x->thismb, 16);
|
2011-06-23 19:54:02 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
|
|
|
|
vp8_activity_masking(cpi, x);
|
2010-10-11 23:37:27 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Is segmentation enabled
|
|
|
|
if (xd->segmentation_enabled) {
|
|
|
|
vp8cx_mb_init_quantizer(cpi, x);
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->active_ptr = cpi->active_map + map_index;
|
Improved coding using 8x8 transform
In summary, this commit encompasses a series of changes in attempt to
improve the 8x8 transform based coding to help overall compression
quality, please refer to the detailed commit history below for what
are the rationale underly the series of changes:
a. A frame level flag to indicate if 8x8 transform is used at all.
b. 8x8 transform is not used for key frames and small image size.
c. On inter coded frame, macroblocks using modes B_PRED, SPLIT_MV
and I8X8_PRED are forced to using 4x4 transform based coding, the
rest uses 8x8 transform based coding.
d. Encoder and decoder has the same assumption on the relationship
between prediction modes and transform size, therefore no signaling
is encoded in bitstream.
e. Mode decision process now calculate the rate and distortion scores
using their respective transforms.
Overall test results:
1. HD set
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120206.html
(avg psnr: 3.09% glb psnr: 3.22%, ssim: 3.90%)
2. Cif set:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120206.html
(avg psnr: -0.03%, glb psnr: -0.02%, ssim: -0.04%)
It should be noted here, as 8x8 transform coding itself is disabled
for cif size clips, the 0.03% loss is purely from the 1 bit/frame
flag overhead on if 8x8 transform is used or not for the frame.
---patch history for future reference---
Patch 1:
this commit tries to select transform size based on macroblock
prediction mode. If the size of a prediction mode is 16x16, then
the macroblock is forced to use 8x8 transform. If the prediction
mode is B_PRED, SPLITMV or I8X8_PRED, then the macroblock is forced
to use 4x4 transform. Tests on the following HD clips showed mixed
results: (all hd clips only used first 100 frames in the test)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_log.html
while the results are mixed and overall negative, it is interesting to
see 8x8 helped a few of the clips.
Patch 2:
this patch tries to hard-wire selection of transform size based on
prediction modes without using segmentation to signal the transform size.
encoder and decoder both takes the same assumption that all macroblocks
use 8x8 transform except when prediciton mode is B_PRED, I8X8_PRED or
SPLITMV. Test results are as follows:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cifmodebase8x8_0125.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_0125log.html
Interestingly, by removing the overhead or coding the segmentation, the
results on this limited HD set have turn positive on average.
Patch 3:
this patch disabled the usage of 8x8 transform on key frames, and kept the
logic from patch 2 for inter frames only. test results on HD set turned
decidedly positive with 8x8 transform enabled on inter frame with 16x16
prediction modes: (avg psnr: .81% glb psnr: .82 ssim: .55%)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdintermode8x8_0125.html
results on cif set still negative overall
Patch 4:
continued from last patch, but now in mode decision process, the rate and
distortion estimates are computed based on 8x8 transform results for MBs
with modes associated with 8x8 transform. This patch also fixed a problem
related to segment based eob coding when 8x8 transform is used. The patch
significantly improved the results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hd8x8RDintermode.html
(avg psnr: 2.70% glb psnr: 2.76% ssim: 3.34%)
results on cif also improved, though they are still negative compared to
baseline that uses 4x4 transform only:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif8x8RDintermode.html
(avg psnr: -.78% glb psnr: -.86% ssim: -.19%)
Patch 5:
This patch does 3 things:
a. a bunch of decoder bug fixes, encodings and decodings were verified
to have matched recon buffer on a number of encodes on cif size mobile and
hd version of _pedestrian.
b. the patch further improved the rate distortion calculation of MBS that
use 8x8 transform. This provided some further gain on compression.
c. the patch also got the experimental work SEG_LVL_EOB to work with 8x8
transformed macroblock, test results indicates it improves the cif set
but hurt the HD set slightly.
Tests results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120201.html
(avg psnr: 3.19% glb psnr: 3.30% ssim: 3.93%)
Test results on cif clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120201.html
(avg psnr: -.47% glb psnr: -.51% ssim: +.28%)
Patch 6:
Added a frame level flag to indicate if 8x8 transform is allowed at all.
temporarily the decision is based on frame size, can be optimized later
one. This get the cif results to basically unchanged, with one bit per
frame overhead on both cif and hd clips.
Patch 8:
Rebase and Merge to head by PGW.
Fixed some suspect 4s that look like hey should be 64s in regard
to segmented EOB. Perhaps #defines would be bette.
Bulit and tested without T8x8 enabled and produces unchanged
output.
Patch 9:
Corrected misalligned code/decode of "txfm_mode" bit.
Limited testing for correct encode and decode with
T8x8 configured on derf clips.
Change-Id: I156e1405d25f81579d579dff8ab9af53944ec49c
2012-02-10 01:12:23 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->update_context = 0;
|
|
|
|
|
|
|
|
if (cm->frame_type == KEY_FRAME) {
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb)
|
|
|
|
vp8cx_encode_intra_super_block(cpi, x, tp, mb_col);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
vp8cx_encode_intra_macro_block(cpi, x, tp, 1);
|
|
|
|
// Note the encoder may have changed the segment_id
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#ifdef MODE_STATS
|
2012-08-10 15:12:43 +02:00
|
|
|
y_modes[mbmi->mode]++;
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
unsigned char *segment_id;
|
|
|
|
int seg_ref_active;
|
2012-07-17 02:49:37 +02:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
if (xd->mode_info_context->mbmi.ref_frame) {
|
|
|
|
unsigned char pred_context;
|
|
|
|
|
|
|
|
pred_context = get_pred_context(cm, xd, PRED_COMP);
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME)
|
|
|
|
cpi->single_pred_count[pred_context]++;
|
|
|
|
else
|
|
|
|
cpi->comp_pred_count[pred_context]++;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb)
|
|
|
|
vp8cx_encode_inter_superblock(cpi, x, tp, recon_yoffset, recon_uvoffset, mb_col, mb_row);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
vp8cx_encode_inter_macroblock(cpi, x, tp,
|
|
|
|
recon_yoffset, recon_uvoffset, 1);
|
|
|
|
// Note the encoder may have changed the segment_id
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#ifdef MODE_STATS
|
2012-08-10 15:12:43 +02:00
|
|
|
inter_y_modes[mbmi->mode]++;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->mode == SPLITMV) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int b;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (b = 0; b < x->partition_info->count; b++) {
|
|
|
|
inter_b_modes[x->partition_info->bmi[b].mode]++;
|
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// If we have just a single reference frame coded for a segment then
|
|
|
|
// exclude from the reference frame counts used to work out
|
|
|
|
// probabilities. NOTE: At the moment we dont support custom trees
|
|
|
|
// for the reference frame coding for each segment but this is a
|
|
|
|
// possible future action.
|
2012-08-10 15:12:43 +02:00
|
|
|
segment_id = &mbmi->segment_id;
|
2012-07-14 00:21:29 +02:00
|
|
|
seg_ref_active = segfeature_active(xd, *segment_id, SEG_LVL_REF_FRAME);
|
|
|
|
if (!seg_ref_active ||
|
|
|
|
((check_segref(xd, *segment_id, INTRA_FRAME) +
|
|
|
|
check_segref(xd, *segment_id, LAST_FRAME) +
|
|
|
|
check_segref(xd, *segment_id, GOLDEN_FRAME) +
|
|
|
|
check_segref(xd, *segment_id, ALTREF_FRAME)) > 1)) {
|
|
|
|
{
|
2012-08-10 15:12:43 +02:00
|
|
|
cpi->count_mb_ref_frame_usage[mbmi->ref_frame]++;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Count of last ref frame 0,0 usage
|
2012-08-10 15:12:43 +02:00
|
|
|
if ((mbmi->mode == ZEROMV) && (mbmi->ref_frame == LAST_FRAME))
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->inter_zz_count++;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// TODO Partitioning is broken!
|
|
|
|
cpi->tplist[mb_row].stop = *tp;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
x->src.y_buffer += 32;
|
|
|
|
x->src.u_buffer += 16;
|
|
|
|
x->src.v_buffer += 16;
|
|
|
|
|
|
|
|
x->gf_active_ptr += 2;
|
|
|
|
x->partition_info += 2;
|
|
|
|
xd->mode_info_context += 2;
|
|
|
|
xd->prev_mode_info_context += 2;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Next MB
|
|
|
|
mb_row += dy;
|
|
|
|
mb_col += dx;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->src.y_buffer += 16 * (dx + dy * x->src.y_stride);
|
|
|
|
x->src.u_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
x->src.v_buffer += 8 * (dx + dy * x->src.uv_stride);
|
|
|
|
|
|
|
|
x->gf_active_ptr += offset_unextended;
|
|
|
|
x->partition_info += offset_extended;
|
|
|
|
xd->mode_info_context += offset_extended;
|
|
|
|
xd->prev_mode_info_context += offset_extended;
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-04-07 01:38:34 +02:00
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
|
|
|
|
(xd->mode_info_context - cpi->common.mip));
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// debug output
|
2012-04-07 01:38:34 +02:00
|
|
|
#if DBG_PRNT_SEGMAP
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
|
|
|
FILE *statsfile;
|
|
|
|
statsfile = fopen("segmap2.stt", "a");
|
|
|
|
fprintf(statsfile, "\n");
|
|
|
|
fclose(statsfile);
|
|
|
|
}
|
|
|
|
#endif
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-04-07 01:38:34 +02:00
|
|
|
static
|
2012-07-14 00:21:29 +02:00
|
|
|
void encode_sb_row(VP8_COMP *cpi,
|
|
|
|
VP8_COMMON *cm,
|
|
|
|
int mb_row,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
MACROBLOCKD *xd,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int *totalrate) {
|
|
|
|
int mb_col;
|
|
|
|
int mb_cols = cm->mb_cols;
|
|
|
|
|
|
|
|
// Initialize the left context for the new SB row
|
2012-08-20 23:43:34 +02:00
|
|
|
vpx_memset(cm->left_context, 0, sizeof(cm->left_context));
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Code each SB in the row
|
|
|
|
for (mb_col = 0; mb_col < mb_cols; mb_col += 2) {
|
2012-08-20 23:43:34 +02:00
|
|
|
int mb_rate = 0, mb_dist = 0;
|
2012-04-07 01:38:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
2012-08-20 23:43:34 +02:00
|
|
|
int sb_rate = INT_MAX, sb_dist;
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
MODE_INFO *mic = xd->mode_info_context;
|
|
|
|
PARTITION_INFO *pi = x->partition_info;
|
|
|
|
signed char *gfa = x->gf_active_ptr;
|
|
|
|
unsigned char *yb = x->src.y_buffer;
|
|
|
|
unsigned char *ub = x->src.u_buffer;
|
|
|
|
unsigned char *vb = x->src.v_buffer;
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
2012-07-14 00:21:29 +02:00
|
|
|
// Pick modes assuming the SB is coded as 4 independent MBs
|
2012-08-20 23:43:34 +02:00
|
|
|
xd->mode_info_context->mbmi.encoded_as_sb = 0;
|
|
|
|
#endif
|
|
|
|
pick_mb_modes(cpi, cm, mb_row, mb_col, x, xd, tp, &mb_rate, &mb_dist);
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
mb_rate += vp8_cost_bit(cm->sb_coded, 0);
|
|
|
|
#endif
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->src.y_buffer -= 32;
|
|
|
|
x->src.u_buffer -= 16;
|
|
|
|
x->src.v_buffer -= 16;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->gf_active_ptr -= 2;
|
|
|
|
x->partition_info -= 2;
|
|
|
|
xd->mode_info_context -= 2;
|
|
|
|
xd->prev_mode_info_context -= 2;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert(x->gf_active_ptr == gfa);
|
|
|
|
assert(x->partition_info == pi);
|
|
|
|
assert(xd->mode_info_context == mic);
|
|
|
|
assert(x->src.y_buffer == yb);
|
|
|
|
assert(x->src.u_buffer == ub);
|
|
|
|
assert(x->src.v_buffer == vb);
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
2012-08-20 23:43:34 +02:00
|
|
|
if (!((( mb_cols & 1) && mb_col == mb_cols - 1) ||
|
|
|
|
((cm->mb_rows & 1) && mb_row == cm->mb_rows - 1))) {
|
|
|
|
/* Pick a mode assuming that it applies to all 4 of the MBs in the SB */
|
|
|
|
xd->mode_info_context->mbmi.encoded_as_sb = 1;
|
|
|
|
pick_sb_modes(cpi, cm, mb_row, mb_col, x, xd, tp, &sb_rate, &sb_dist);
|
|
|
|
sb_rate += vp8_cost_bit(cm->sb_coded, 1);
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
/* Decide whether to encode as a SB or 4xMBs */
|
|
|
|
if (sb_rate < INT_MAX &&
|
|
|
|
RDCOST(x->rdmult, x->rddiv, sb_rate, sb_dist) <
|
|
|
|
RDCOST(x->rdmult, x->rddiv, mb_rate, mb_dist)) {
|
|
|
|
xd->mode_info_context->mbmi.encoded_as_sb = 1;
|
|
|
|
xd->mode_info_context[1].mbmi.encoded_as_sb = 1;
|
|
|
|
xd->mode_info_context[cm->mode_info_stride].mbmi.encoded_as_sb = 1;
|
|
|
|
xd->mode_info_context[1 + cm->mode_info_stride].mbmi.encoded_as_sb = 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
*totalrate += sb_rate;
|
|
|
|
} else
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
xd->mode_info_context->mbmi.encoded_as_sb = 0;
|
|
|
|
if (cm->mb_cols - 1 > mb_col)
|
|
|
|
xd->mode_info_context[1].mbmi.encoded_as_sb = 0;
|
|
|
|
if (cm->mb_rows - 1 > mb_row) {
|
|
|
|
xd->mode_info_context[cm->mode_info_stride].mbmi.encoded_as_sb = 0;
|
|
|
|
if (cm->mb_cols - 1 > mb_col)
|
|
|
|
xd->mode_info_context[1 + cm->mode_info_stride].mbmi.encoded_as_sb = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
*totalrate += mb_rate;
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
/* Encode SB using best computed mode(s) */
|
2012-07-14 00:21:29 +02:00
|
|
|
encode_sb(cpi, cm, mb_row, mb_col, x, xd, tp);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert(x->gf_active_ptr == gfa + 2);
|
|
|
|
assert(x->partition_info == pi + 2);
|
|
|
|
assert(xd->mode_info_context == mic + 2);
|
|
|
|
assert(x->src.y_buffer == yb + 32);
|
|
|
|
assert(x->src.u_buffer == ub + 16);
|
|
|
|
assert(x->src.v_buffer == vb + 16);
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// this is to account for the border
|
|
|
|
x->gf_active_ptr += mb_cols - (mb_cols & 0x1);
|
|
|
|
x->partition_info += xd->mode_info_stride + 1 - (mb_cols & 0x1);
|
|
|
|
xd->mode_info_context += xd->mode_info_stride + 1 - (mb_cols & 0x1);
|
|
|
|
xd->prev_mode_info_context += xd->mode_info_stride + 1 - (mb_cols & 0x1);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
assert((xd->prev_mode_info_context - cpi->common.prev_mip) ==
|
|
|
|
(xd->mode_info_context - cpi->common.mip));
|
2011-09-30 17:45:16 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// GF active flags data structure
|
|
|
|
x->gf_active_ptr = (signed char *)cpi->gf_active_flags;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Activity map pointer
|
|
|
|
x->mb_activity_ptr = cpi->mb_activity_map;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->act_zbin_adj = 0;
|
|
|
|
cpi->seg0_idx = 0;
|
|
|
|
vpx_memset(cpi->ref_pred_count, 0, sizeof(cpi->ref_pred_count));
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->partition_info = x->pi;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context = cm->mi;
|
|
|
|
xd->mode_info_stride = cm->mode_info_stride;
|
|
|
|
xd->prev_mode_info_context = cm->prev_mi;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->frame_type = cm->frame_type;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->frames_since_golden = cm->frames_since_golden;
|
|
|
|
xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// reset intra mode contexts
|
|
|
|
if (cm->frame_type == KEY_FRAME)
|
|
|
|
vp8_init_mbmode_probs(cm);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Copy data over into macro block data structures.
|
|
|
|
x->src = * cpi->Source;
|
|
|
|
xd->pre = cm->yv12_fb[cm->lst_fb_idx];
|
|
|
|
xd->dst = cm->yv12_fb[cm->new_fb_idx];
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// set up frame for intra coded blocks
|
|
|
|
vp8_setup_intra_recon(&cm->yv12_fb[cm->new_fb_idx]);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_build_block_offsets(x);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_setup_block_dptrs(&x->e_mbd);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_setup_block_ptrs(x);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context->mbmi.mode = DC_PRED;
|
|
|
|
xd->mode_info_context->mbmi.uv_mode = DC_PRED;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_zero(cpi->count_mb_ref_frame_usage)
|
|
|
|
vp8_zero(cpi->bmode_count)
|
|
|
|
vp8_zero(cpi->ymode_count)
|
|
|
|
vp8_zero(cpi->i8x8_mode_count)
|
|
|
|
vp8_zero(cpi->y_uv_mode_count)
|
|
|
|
vp8_zero(cpi->sub_mv_ref_count)
|
|
|
|
vp8_zero(cpi->mbsplit_count)
|
|
|
|
vp8_zero(cpi->common.fc.mv_ref_ct)
|
|
|
|
vp8_zero(cpi->common.fc.mv_ref_ct_a)
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
vp8_zero(cpi->sb_ymode_count)
|
|
|
|
cpi->sb_count = 0;
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// vp8_zero(cpi->uv_mode_count)
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->mvc = cm->fc.mvc;
|
|
|
|
x->mvc_hp = cm->fc.mvc_hp;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memset(cm->above_context, 0,
|
|
|
|
sizeof(ENTROPY_CONTEXT_PLANES) * cm->mb_cols);
|
2011-06-13 15:50:54 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->fullpixel_mask = 0xffffffff;
|
|
|
|
if (cm->full_pixel)
|
|
|
|
xd->fullpixel_mask = 0xfffffff8;
|
2011-06-08 17:00:59 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void encode_frame_internal(VP8_COMP *cpi) {
|
|
|
|
int mb_row;
|
|
|
|
MACROBLOCK *const x = & cpi->mb;
|
|
|
|
VP8_COMMON *const cm = & cpi->common;
|
|
|
|
MACROBLOCKD *const xd = & x->e_mbd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
TOKENEXTRA *tp = cpi->tok;
|
|
|
|
int totalrate;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Compute a modified set of reference frame probabilities to use when
|
|
|
|
// prediction fails. These are based on the current general estimates for
|
|
|
|
// this frame which may be updated with each iteration of the recode loop.
|
|
|
|
compute_mod_refprobs(cm);
|
2011-09-30 17:45:16 +02:00
|
|
|
|
2012-08-24 16:44:01 +02:00
|
|
|
#if CONFIG_NEW_MVREF
|
|
|
|
// temp stats reset
|
|
|
|
vp8_zero( cpi->mv_ref_sum_distance );
|
|
|
|
vp8_zero( cpi->best_ref_index_counts );
|
|
|
|
#endif
|
|
|
|
|
2011-09-30 17:45:16 +02:00
|
|
|
// debug output
|
2011-10-07 17:58:28 +02:00
|
|
|
#if DBG_PRNT_SEGMAP
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
|
|
|
FILE *statsfile;
|
|
|
|
statsfile = fopen("segmap2.stt", "a");
|
|
|
|
fprintf(statsfile, "\n");
|
|
|
|
fclose(statsfile);
|
|
|
|
}
|
2011-09-30 17:45:16 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
totalrate = 0;
|
|
|
|
|
|
|
|
// Functions setup for all frame types so we can use MC in AltRef
|
2012-07-18 22:43:01 +02:00
|
|
|
vp8_setup_interp_filters(xd, cm->mcomp_filter_type, cm);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Reset frame count of inter 0,0 motion vector usage.
|
|
|
|
cpi->inter_zz_count = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->prediction_error = 0;
|
|
|
|
cpi->intra_error = 0;
|
|
|
|
cpi->skip_true_count[0] = cpi->skip_true_count[1] = cpi->skip_true_count[2] = 0;
|
|
|
|
cpi->skip_false_count[0] = cpi->skip_false_count[1] = cpi->skip_false_count[2] = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-06-26 01:23:58 +02:00
|
|
|
#if CONFIG_PRED_FILTER
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->current_video_frame == 0) {
|
|
|
|
// Initially assume that we'll signal the prediction filter
|
|
|
|
// state at the frame level and that it is off.
|
|
|
|
cpi->common.pred_filter_mode = 0;
|
|
|
|
cpi->common.prob_pred_filter_off = 128;
|
|
|
|
}
|
|
|
|
cpi->pred_filter_on_count = 0;
|
|
|
|
cpi->pred_filter_off_count = 0;
|
2012-07-18 22:43:01 +02:00
|
|
|
#endif
|
|
|
|
#if CONFIG_SWITCHABLE_INTERP
|
|
|
|
vp8_zero(cpi->switchable_interp_count);
|
2012-06-26 01:23:58 +02:00
|
|
|
#endif
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
#if 0
|
2012-07-14 00:21:29 +02:00
|
|
|
// Experimental code
|
|
|
|
cpi->frame_distortion = 0;
|
|
|
|
cpi->last_mb_distortion = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_context = cm->mi;
|
|
|
|
xd->prev_mode_info_context = cm->prev_mi;
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_zero(cpi->MVcount);
|
|
|
|
vp8_zero(cpi->MVcount_hp);
|
|
|
|
vp8_zero(cpi->coef_counts);
|
|
|
|
vp8_zero(cpi->coef_counts_8x8);
|
2012-08-03 02:03:14 +02:00
|
|
|
#if CONFIG_TX16X16
|
|
|
|
vp8_zero(cpi->coef_counts_16x16);
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8cx_frame_init_quantizer(cpi);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_initialize_rd_consts(cpi, cm->base_qindex + cm->y1dc_delta_q);
|
|
|
|
vp8cx_initialize_me_consts(cpi, cm->base_qindex);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
// Initialize encode frame context.
|
2011-06-08 17:00:59 +02:00
|
|
|
init_encode_frame_mb_context(cpi);
|
2012-02-10 01:11:00 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Build a frame level activity map
|
|
|
|
build_activity_map(cpi);
|
|
|
|
}
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// re-initencode frame context.
|
|
|
|
init_encode_frame_mb_context(cpi);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-10 03:25:29 +02:00
|
|
|
vpx_memset(cpi->rd_comp_pred_diff, 0, sizeof(cpi->rd_comp_pred_diff));
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memset(cpi->single_pred_count, 0, sizeof(cpi->single_pred_count));
|
|
|
|
vpx_memset(cpi->comp_pred_count, 0, sizeof(cpi->comp_pred_count));
|
2011-02-05 06:29:25 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
|
|
|
struct vpx_usec_timer emr_timer;
|
|
|
|
vpx_usec_timer_start(&emr_timer);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
|
|
|
// For each row of SBs in the frame
|
|
|
|
for (mb_row = 0; mb_row < cm->mb_rows; mb_row += 2) {
|
|
|
|
int offset = (cm->mb_cols + 1) & ~0x1;
|
2011-02-05 06:29:25 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
encode_sb_row(cpi, cm, mb_row, x, xd, &tp, &totalrate);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// adjust to the next row of SBs
|
|
|
|
x->src.y_buffer += 32 * x->src.y_stride - 16 * offset;
|
|
|
|
x->src.u_buffer += 16 * x->src.uv_stride - 8 * offset;
|
|
|
|
x->src.v_buffer += 16 * x->src.uv_stride - 8 * offset;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->tok_count = tp - cpi->tok;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_usec_timer_mark(&emr_timer);
|
|
|
|
cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// 256 rate units to the bit,
|
|
|
|
// projected_frame_size in units of BYTES
|
|
|
|
cpi->projected_frame_size = totalrate >> 8;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
2012-07-14 00:21:29 +02:00
|
|
|
// Keep record of the total distortion this time around for future use
|
|
|
|
cpi->last_frame_distortion = cpi->frame_distortion;
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static int check_dual_ref_flags(VP8_COMP *cpi) {
|
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
|
|
|
int ref_flags = cpi->ref_frame_flags;
|
|
|
|
|
|
|
|
if (segfeature_active(xd, 1, SEG_LVL_REF_FRAME)) {
|
|
|
|
if ((ref_flags & (VP8_LAST_FLAG | VP8_GOLD_FLAG)) == (VP8_LAST_FLAG | VP8_GOLD_FLAG) &&
|
|
|
|
check_segref(xd, 1, LAST_FRAME))
|
|
|
|
return 1;
|
|
|
|
if ((ref_flags & (VP8_GOLD_FLAG | VP8_ALT_FLAG)) == (VP8_GOLD_FLAG | VP8_ALT_FLAG) &&
|
|
|
|
check_segref(xd, 1, GOLDEN_FRAME))
|
|
|
|
return 1;
|
|
|
|
if ((ref_flags & (VP8_ALT_FLAG | VP8_LAST_FLAG)) == (VP8_ALT_FLAG | VP8_LAST_FLAG) &&
|
|
|
|
check_segref(xd, 1, ALTREF_FRAME))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return (!!(ref_flags & VP8_GOLD_FLAG) +
|
|
|
|
!!(ref_flags & VP8_LAST_FLAG) +
|
|
|
|
!!(ref_flags & VP8_ALT_FLAG)) >= 2;
|
|
|
|
}
|
2012-03-22 18:03:14 +01:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_encode_frame(VP8_COMP *cpi) {
|
|
|
|
if (cpi->sf.RD) {
|
2012-08-10 03:25:29 +02:00
|
|
|
int i, frame_type, pred_type;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This code does a single RD pass over the whole frame assuming
|
|
|
|
* either compound, single or hybrid prediction as per whatever has
|
|
|
|
* worked best for that type of frame in the past.
|
|
|
|
* It also predicts whether another coding mode would have worked
|
|
|
|
* better that this coding mode. If that is the case, it remembers
|
|
|
|
* that for subsequent frames. If the difference is above a certain
|
|
|
|
* threshold, it will actually re-encode the current frame using
|
|
|
|
* that different coding mode.
|
|
|
|
*/
|
|
|
|
if (cpi->common.frame_type == KEY_FRAME)
|
|
|
|
frame_type = 0;
|
|
|
|
else if (cpi->is_src_frame_alt_ref && cpi->common.refresh_golden_frame)
|
|
|
|
frame_type = 3;
|
|
|
|
else if (cpi->common.refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
|
|
|
|
frame_type = 1;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
else
|
2012-07-14 00:21:29 +02:00
|
|
|
frame_type = 2;
|
|
|
|
|
|
|
|
if (frame_type == 3)
|
|
|
|
pred_type = SINGLE_PREDICTION_ONLY;
|
|
|
|
else if (cpi->rd_prediction_type_threshes[frame_type][1] >
|
2012-07-17 01:46:46 +02:00
|
|
|
cpi->rd_prediction_type_threshes[frame_type][0] &&
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->rd_prediction_type_threshes[frame_type][1] >
|
2012-07-17 01:46:46 +02:00
|
|
|
cpi->rd_prediction_type_threshes[frame_type][2] &&
|
|
|
|
check_dual_ref_flags(cpi) && cpi->static_mb_pct == 100)
|
2012-07-14 00:21:29 +02:00
|
|
|
pred_type = COMP_PREDICTION_ONLY;
|
|
|
|
else if (cpi->rd_prediction_type_threshes[frame_type][0] >
|
2012-07-17 01:46:46 +02:00
|
|
|
cpi->rd_prediction_type_threshes[frame_type][2])
|
2012-07-14 00:21:29 +02:00
|
|
|
pred_type = SINGLE_PREDICTION_ONLY;
|
|
|
|
else
|
|
|
|
pred_type = HYBRID_PREDICTION;
|
|
|
|
|
|
|
|
cpi->common.comp_pred_mode = pred_type;
|
|
|
|
encode_frame_internal(cpi);
|
|
|
|
|
2012-08-10 03:25:29 +02:00
|
|
|
for (i = 0; i < NB_PREDICTION_TYPES; ++i) {
|
|
|
|
int diff = cpi->rd_comp_pred_diff[i] / cpi->common.MBs;
|
|
|
|
cpi->rd_prediction_type_threshes[frame_type][i] += diff;
|
|
|
|
cpi->rd_prediction_type_threshes[frame_type][i] >>= 1;
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (cpi->common.comp_pred_mode == HYBRID_PREDICTION) {
|
|
|
|
int single_count_zero = 0;
|
|
|
|
int comp_count_zero = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < COMP_PRED_CONTEXTS; i++) {
|
|
|
|
single_count_zero += cpi->single_pred_count[i];
|
|
|
|
comp_count_zero += cpi->comp_pred_count[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (comp_count_zero == 0) {
|
|
|
|
cpi->common.comp_pred_mode = SINGLE_PREDICTION_ONLY;
|
|
|
|
} else if (single_count_zero == 0) {
|
|
|
|
cpi->common.comp_pred_mode = COMP_PREDICTION_ONLY;
|
|
|
|
}
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
encode_frame_internal(cpi);
|
|
|
|
}
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_setup_block_ptrs(MACROBLOCK *x) {
|
|
|
|
int r, c;
|
|
|
|
int i;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->block[24].src_diff = x->src_diff + 384;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 0; i < 25; i++) {
|
|
|
|
x->block[i].coeff = x->coeff + i * 16;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_build_block_offsets(MACROBLOCK *x) {
|
|
|
|
int block = 0;
|
|
|
|
int br, bc;
|
|
|
|
|
|
|
|
vp8_build_block_doffsets(&x->e_mbd);
|
|
|
|
|
|
|
|
// y blocks
|
|
|
|
x->thismb_ptr = &x->thismb[0];
|
|
|
|
for (br = 0; br < 4; br++) {
|
|
|
|
for (bc = 0; bc < 4; bc++) {
|
|
|
|
BLOCK *this_block = &x->block[block];
|
|
|
|
// 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;
|
|
|
|
++block;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void sum_intra_stats(VP8_COMP *cpi, MACROBLOCK *x) {
|
|
|
|
const MACROBLOCKD *xd = & x->e_mbd;
|
|
|
|
const MB_PREDICTION_MODE m = xd->mode_info_context->mbmi.mode;
|
|
|
|
const MB_PREDICTION_MODE uvm = xd->mode_info_context->mbmi.uv_mode;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#ifdef MODE_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
const int is_key = cpi->common.frame_type == KEY_FRAME;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
++ (is_key ? uv_modes : inter_uv_modes)[uvm];
|
|
|
|
++ uv_modes_y[m][uvm];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (m == B_PRED) {
|
|
|
|
unsigned int *const bct = is_key ? b_modes : inter_b_modes;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int b = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
do {
|
|
|
|
++ bct[xd->block[b].bmi.as_mode.first];
|
|
|
|
} while (++b < 16);
|
|
|
|
}
|
2011-12-07 22:03:57 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (m == I8X8_PRED) {
|
|
|
|
i8x8_modes[xd->block[0].bmi.as_mode.first]++;
|
|
|
|
i8x8_modes[xd->block[2].bmi.as_mode.first]++;
|
|
|
|
i8x8_modes[xd->block[8].bmi.as_mode.first]++;
|
|
|
|
i8x8_modes[xd->block[10].bmi.as_mode.first]++;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
if (xd->mode_info_context->mbmi.encoded_as_sb) {
|
|
|
|
++cpi->sb_ymode_count[m];
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
++cpi->ymode_count[m];
|
2012-07-14 00:21:29 +02:00
|
|
|
if (m != I8X8_PRED)
|
|
|
|
++cpi->y_uv_mode_count[m][uvm];
|
|
|
|
else {
|
|
|
|
cpi->i8x8_mode_count[xd->block[0].bmi.as_mode.first]++;
|
|
|
|
cpi->i8x8_mode_count[xd->block[2].bmi.as_mode.first]++;
|
|
|
|
cpi->i8x8_mode_count[xd->block[8].bmi.as_mode.first]++;
|
|
|
|
cpi->i8x8_mode_count[xd->block[10].bmi.as_mode.first]++;
|
|
|
|
}
|
|
|
|
if (m == B_PRED) {
|
|
|
|
int b = 0;
|
|
|
|
do {
|
|
|
|
++ cpi->bmode_count[xd->block[b].bmi.as_mode.first];
|
|
|
|
} while (++b < 16);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
// Experimental stub function to create a per MB zbin adjustment based on
|
|
|
|
// some previously calculated measure of MB activity.
|
2012-07-14 00:21:29 +02:00
|
|
|
static void adjust_act_zbin(VP8_COMP *cpi, MACROBLOCK *x) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if USE_ACT_INDEX
|
2012-07-14 00:21:29 +02:00
|
|
|
x->act_zbin_adj = *(x->mb_activity_ptr);
|
2011-06-08 17:00:59 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
int64_t a;
|
|
|
|
int64_t b;
|
|
|
|
int64_t act = *(x->mb_activity_ptr);
|
|
|
|
|
|
|
|
// Apply the masking to the RD multiplier.
|
|
|
|
a = act + 4 * cpi->activity_avg;
|
|
|
|
b = 4 * act + cpi->activity_avg;
|
|
|
|
|
|
|
|
if (act > cpi->activity_avg)
|
|
|
|
x->act_zbin_adj = (int)(((int64_t)b + (a >> 1)) / a) - 1;
|
|
|
|
else
|
|
|
|
x->act_zbin_adj = 1 - (int)(((int64_t)a + (b >> 1)) / b);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
static void update_sb_skip_coeff_state(VP8_COMP *cpi,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
ENTROPY_CONTEXT_PLANES ta[4],
|
|
|
|
ENTROPY_CONTEXT_PLANES tl[4],
|
|
|
|
TOKENEXTRA *t[4],
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int skip[4])
|
|
|
|
{
|
|
|
|
TOKENEXTRA tokens[4][16 * 24];
|
|
|
|
int n_tokens[4], n;
|
|
|
|
|
|
|
|
// if there were no skips, we don't need to do anything
|
|
|
|
if (!skip[0] && !skip[1] && !skip[2] && !skip[3])
|
|
|
|
return;
|
|
|
|
|
|
|
|
// if we don't do coeff skipping for this frame, we don't
|
|
|
|
// need to do anything here
|
|
|
|
if (!cpi->common.mb_no_coeff_skip)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// if all 4 MBs skipped coeff coding, nothing to be done
|
|
|
|
if (skip[0] && skip[1] && skip[2] && skip[3])
|
|
|
|
return;
|
|
|
|
|
|
|
|
// so the situation now is that we want to skip coeffs
|
|
|
|
// for some MBs, but not all, and we didn't code EOB
|
|
|
|
// coefficients for them. However, the skip flag for this
|
|
|
|
// SB will be 0 overall, so we need to insert EOBs in the
|
|
|
|
// middle of the token tree. Do so here.
|
|
|
|
n_tokens[0] = t[1] - t[0];
|
|
|
|
n_tokens[1] = t[2] - t[1];
|
|
|
|
n_tokens[2] = t[3] - t[2];
|
|
|
|
n_tokens[3] = *tp - t[3];
|
|
|
|
if (n_tokens[0])
|
|
|
|
memcpy(tokens[0], t[0], n_tokens[0] * sizeof(*t[0]));
|
|
|
|
if (n_tokens[1])
|
|
|
|
memcpy(tokens[1], t[1], n_tokens[1] * sizeof(*t[0]));
|
|
|
|
if (n_tokens[2])
|
|
|
|
memcpy(tokens[2], t[2], n_tokens[2] * sizeof(*t[0]));
|
|
|
|
if (n_tokens[3])
|
|
|
|
memcpy(tokens[3], t[3], n_tokens[3] * sizeof(*t[0]));
|
|
|
|
|
|
|
|
// reset pointer, stuff EOBs where necessary
|
|
|
|
*tp = t[0];
|
|
|
|
for (n = 0; n < 4; n++) {
|
|
|
|
if (skip[n]) {
|
|
|
|
x->e_mbd.above_context = &ta[n];
|
|
|
|
x->e_mbd.left_context = &tl[n];
|
|
|
|
vp8_stuff_mb_8x8(cpi, &x->e_mbd, tp, 0);
|
|
|
|
} else {
|
|
|
|
if (n_tokens[n]) {
|
|
|
|
memcpy(*tp, tokens[n], sizeof(*t[0]) * n_tokens[n]);
|
|
|
|
}
|
|
|
|
(*tp) += n_tokens[n];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void vp8cx_encode_intra_super_block(VP8_COMP *cpi,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
TOKENEXTRA **t,
|
|
|
|
int mb_col) {
|
|
|
|
const int output_enabled = 1;
|
|
|
|
int n;
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
VP8_COMMON *cm = &cpi->common;
|
2012-08-21 02:45:36 +02:00
|
|
|
const uint8_t *src = x->src.y_buffer;
|
|
|
|
uint8_t *dst = xd->dst.y_buffer;
|
|
|
|
const uint8_t *usrc = x->src.u_buffer;
|
|
|
|
uint8_t *udst = xd->dst.u_buffer;
|
|
|
|
const uint8_t *vsrc = x->src.v_buffer;
|
|
|
|
uint8_t *vdst = xd->dst.v_buffer;
|
2012-08-20 23:43:34 +02:00
|
|
|
int src_y_stride = x->src.y_stride, dst_y_stride = xd->dst.y_stride;
|
|
|
|
int src_uv_stride = x->src.uv_stride, dst_uv_stride = xd->dst.uv_stride;
|
|
|
|
const VP8_ENCODER_RTCD *rtcd = IF_RTCD(&cpi->rtcd);
|
|
|
|
TOKENEXTRA *tp[4];
|
|
|
|
int skip[4];
|
|
|
|
MODE_INFO *mi = x->e_mbd.mode_info_context;
|
|
|
|
ENTROPY_CONTEXT_PLANES ta[4], tl[4];
|
|
|
|
|
|
|
|
if ((cpi->oxcf.tuning == VP8_TUNE_SSIM) && output_enabled) {
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
vp8_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* test code: set transform size based on mode selection */
|
|
|
|
if (cpi->common.txfm_mode == ALLOW_8X8) {
|
|
|
|
x->e_mbd.mode_info_context->mbmi.txfm_size = TX_8X8;
|
|
|
|
x->e_mbd.mode_info_context[1].mbmi.txfm_size = TX_8X8;
|
|
|
|
x->e_mbd.mode_info_context[cm->mode_info_stride].mbmi.txfm_size = TX_8X8;
|
|
|
|
x->e_mbd.mode_info_context[cm->mode_info_stride+1].mbmi.txfm_size = TX_8X8;
|
|
|
|
cpi->t8x8_count++;
|
|
|
|
} else {
|
|
|
|
x->e_mbd.mode_info_context->mbmi.txfm_size = TX_4X4;
|
|
|
|
cpi->t4x4_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sby_s)(&x->e_mbd);
|
|
|
|
RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sbuv_s)(&x->e_mbd);
|
|
|
|
|
|
|
|
assert(x->e_mbd.mode_info_context->mbmi.txfm_size == TX_8X8);
|
|
|
|
for (n = 0; n < 4; n++)
|
|
|
|
{
|
|
|
|
int x_idx = n & 1, y_idx = n >> 1;
|
|
|
|
|
|
|
|
xd->above_context = cm->above_context + mb_col + (n & 1);
|
|
|
|
xd->left_context = cm->left_context + (n >> 1);
|
|
|
|
|
|
|
|
vp8_subtract_mby_s_c(x->src_diff,
|
|
|
|
src + x_idx * 16 + y_idx * 16 * src_y_stride,
|
|
|
|
src_y_stride,
|
|
|
|
dst + x_idx * 16 + y_idx * 16 * dst_y_stride,
|
|
|
|
dst_y_stride);
|
|
|
|
vp8_subtract_mbuv_s_c(x->src_diff,
|
|
|
|
usrc + x_idx * 8 + y_idx * 8 * src_uv_stride,
|
|
|
|
vsrc + x_idx * 8 + y_idx * 8 * src_uv_stride,
|
|
|
|
src_uv_stride,
|
|
|
|
udst + x_idx * 8 + y_idx * 8 * dst_uv_stride,
|
|
|
|
vdst + x_idx * 8 + y_idx * 8 * dst_uv_stride,
|
|
|
|
dst_uv_stride);
|
|
|
|
vp8_transform_intra_mby_8x8(x);
|
|
|
|
vp8_transform_mbuv_8x8(x);
|
|
|
|
vp8_quantize_mby_8x8(x);
|
|
|
|
vp8_quantize_mbuv_8x8(x);
|
|
|
|
if (x->optimize) {
|
|
|
|
vp8_optimize_mby_8x8(x, rtcd);
|
|
|
|
vp8_optimize_mbuv_8x8(x, rtcd);
|
|
|
|
}
|
|
|
|
vp8_inverse_transform_mby_8x8(IF_RTCD(&rtcd->common->idct), &x->e_mbd);
|
|
|
|
vp8_inverse_transform_mbuv_8x8(IF_RTCD(&rtcd->common->idct), &x->e_mbd);
|
|
|
|
vp8_recon_mby_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd,
|
|
|
|
dst + x_idx * 16 + y_idx * 16 * dst_y_stride);
|
|
|
|
vp8_recon_mbuv_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd,
|
|
|
|
udst + x_idx * 8 + y_idx * 8 * dst_uv_stride,
|
|
|
|
vdst + x_idx * 8 + y_idx * 8 * dst_uv_stride);
|
|
|
|
|
|
|
|
if (output_enabled) {
|
|
|
|
memcpy(&ta[n], xd->above_context, sizeof(ta[n]));
|
|
|
|
memcpy(&tl[n], xd->left_context, sizeof(tl[n]));
|
|
|
|
tp[n] = *t;
|
|
|
|
xd->mode_info_context = mi + x_idx + y_idx * cm->mode_info_stride;
|
|
|
|
vp8_tokenize_mb(cpi, &x->e_mbd, t, 0);
|
|
|
|
skip[n] = xd->mode_info_context->mbmi.mb_skip_coeff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (output_enabled) {
|
|
|
|
// Tokenize
|
|
|
|
xd->mode_info_context = mi;
|
|
|
|
sum_intra_stats(cpi, x);
|
|
|
|
update_sb_skip_coeff_state(cpi, x, ta, tl, tp, t, skip);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-04-07 01:38:34 +02:00
|
|
|
void vp8cx_encode_intra_macro_block(VP8_COMP *cpi,
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCK *x,
|
|
|
|
TOKENEXTRA **t,
|
|
|
|
int output_enabled) {
|
2012-08-10 15:12:43 +02:00
|
|
|
MB_MODE_INFO * mbmi = &x->e_mbd.mode_info_context->mbmi;
|
2012-07-14 00:21:29 +02:00
|
|
|
if ((cpi->oxcf.tuning == VP8_TUNE_SSIM) && output_enabled) {
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
vp8_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* test code: set transform size based on mode selection */
|
2012-08-03 02:03:14 +02:00
|
|
|
#if CONFIG_TX16X16
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->mode <= TM_PRED) {
|
|
|
|
mbmi->txfm_size = TX_16X16;
|
2012-08-03 02:03:14 +02:00
|
|
|
cpi->t16x16_count++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->common.txfm_mode == ALLOW_8X8
|
2012-08-10 15:12:43 +02:00
|
|
|
&& mbmi->mode != I8X8_PRED
|
|
|
|
&& mbmi->mode != B_PRED) {
|
|
|
|
mbmi->txfm_size = TX_8X8;
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->t8x8_count++;
|
|
|
|
} else {
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->txfm_size = TX_4X4;
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->t4x4_count++;
|
|
|
|
}
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->mode == I8X8_PRED) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_encode_intra8x8mby(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
vp8_encode_intra8x8mbuv(IF_RTCD(&cpi->rtcd), x);
|
2012-08-10 15:12:43 +02:00
|
|
|
} else if (mbmi->mode == B_PRED)
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
else
|
|
|
|
vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->mode != I8X8_PRED)
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
|
|
|
|
if (output_enabled) {
|
|
|
|
// Tokenize
|
|
|
|
sum_intra_stats(cpi, x);
|
2012-08-06 19:51:20 +02:00
|
|
|
vp8_tokenize_mb(cpi, &x->e_mbd, t, 0);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-08-14 01:50:03 +02:00
|
|
|
#if CONFIG_NEWBESTREFMV
|
2012-08-06 19:51:20 +02:00
|
|
|
else
|
|
|
|
vp8_tokenize_mb(cpi, &x->e_mbd, t, 1);
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
#ifdef SPEEDSTATS
|
|
|
|
extern int cnt_pm;
|
|
|
|
#endif
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
extern void vp8_fix_contexts(MACROBLOCKD *xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-03 02:03:14 +02:00
|
|
|
void vp8cx_encode_inter_macroblock (VP8_COMP *cpi, MACROBLOCK *x,
|
|
|
|
TOKENEXTRA **t, int recon_yoffset,
|
|
|
|
int recon_uvoffset, int output_enabled) {
|
2012-07-14 00:21:29 +02:00
|
|
|
VP8_COMMON *cm = &cpi->common;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2012-08-10 15:12:43 +02:00
|
|
|
MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
|
|
|
|
unsigned char *segment_id = &mbmi->segment_id;
|
2012-07-14 00:21:29 +02:00
|
|
|
int seg_ref_active;
|
|
|
|
unsigned char ref_pred_flag;
|
|
|
|
|
|
|
|
x->skip = 0;
|
2012-08-20 23:43:34 +02:00
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
assert(!xd->mode_info_context->mbmi.encoded_as_sb);
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-07-18 22:43:01 +02:00
|
|
|
#if CONFIG_SWITCHABLE_INTERP
|
2012-08-10 15:12:43 +02:00
|
|
|
vp8_setup_interp_filters(xd, mbmi->interp_filter, cm);
|
2012-07-18 22:43:01 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
// Adjust the zbin based on this MB rate.
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Experimental code. Special case for gf and arf zeromv modes.
|
|
|
|
// Increase zbin size to suppress noise
|
|
|
|
cpi->zbin_mode_boost = 0;
|
|
|
|
if (cpi->zbin_mode_boost_enabled) {
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->ref_frame != INTRA_FRAME) {
|
|
|
|
if (mbmi->mode == ZEROMV) {
|
|
|
|
if (mbmi->ref_frame != LAST_FRAME)
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
|
|
|
|
else
|
|
|
|
cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
|
2012-08-10 15:12:43 +02:00
|
|
|
} else if (mbmi->mode == SPLITMV)
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->zbin_mode_boost = 0;
|
|
|
|
else
|
|
|
|
cpi->zbin_mode_boost = MV_ZBIN_BOOST;
|
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
seg_ref_active = segfeature_active(xd, *segment_id, SEG_LVL_REF_FRAME);
|
|
|
|
|
|
|
|
// SET VARIOUS PREDICTION FLAGS
|
|
|
|
|
|
|
|
// Did the chosen reference frame match its predicted value.
|
2012-08-10 15:12:43 +02:00
|
|
|
ref_pred_flag = ((mbmi->ref_frame == get_pred_ref(cm, xd)));
|
2012-07-14 00:21:29 +02:00
|
|
|
set_pred_flag(xd, PRED_REF, ref_pred_flag);
|
|
|
|
|
|
|
|
/* test code: set transform size based on mode selection */
|
2012-08-03 02:03:14 +02:00
|
|
|
#if CONFIG_TX16X16
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->mode <= TM_PRED || mbmi->mode == NEWMV || mbmi->mode == ZEROMV ||
|
|
|
|
mbmi->mode == NEARMV || mbmi->mode == NEARESTMV) {
|
|
|
|
mbmi->txfm_size = TX_16X16;
|
2012-08-03 02:03:14 +02:00
|
|
|
cpi->t16x16_count++;
|
|
|
|
} else
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->common.txfm_mode == ALLOW_8X8
|
2012-08-10 15:12:43 +02:00
|
|
|
&& mbmi->mode != I8X8_PRED
|
|
|
|
&& mbmi->mode != B_PRED
|
|
|
|
&& mbmi->mode != SPLITMV) {
|
|
|
|
mbmi->txfm_size = TX_8X8;
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->t8x8_count++;
|
|
|
|
} else {
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->txfm_size = TX_4X4;
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->t4x4_count++;
|
|
|
|
}
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->ref_frame == INTRA_FRAME) {
|
|
|
|
if (mbmi->mode == B_PRED) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
|
2012-08-10 15:12:43 +02:00
|
|
|
} else if (mbmi->mode == I8X8_PRED) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_encode_intra8x8mby(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
vp8_encode_intra8x8mbuv(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
} else {
|
|
|
|
vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
|
|
|
|
vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (output_enabled)
|
|
|
|
sum_intra_stats(cpi, x);
|
|
|
|
} else {
|
|
|
|
int ref_fb_idx;
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->ref_frame == LAST_FRAME)
|
2012-07-14 00:21:29 +02:00
|
|
|
ref_fb_idx = cpi->common.lst_fb_idx;
|
2012-08-10 15:12:43 +02:00
|
|
|
else if (mbmi->ref_frame == GOLDEN_FRAME)
|
2012-07-14 00:21:29 +02:00
|
|
|
ref_fb_idx = cpi->common.gld_fb_idx;
|
2012-04-07 01:38:34 +02:00
|
|
|
else
|
2012-07-14 00:21:29 +02:00
|
|
|
ref_fb_idx = cpi->common.alt_fb_idx;
|
|
|
|
|
|
|
|
xd->pre.y_buffer = cpi->common.yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
|
|
|
|
xd->pre.u_buffer = cpi->common.yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
|
|
|
|
xd->pre.v_buffer = cpi->common.yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->second_ref_frame) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int second_ref_fb_idx;
|
|
|
|
|
2012-08-10 15:12:43 +02:00
|
|
|
if (mbmi->second_ref_frame == LAST_FRAME)
|
2012-07-14 00:21:29 +02:00
|
|
|
second_ref_fb_idx = cpi->common.lst_fb_idx;
|
2012-08-10 15:12:43 +02:00
|
|
|
else if (mbmi->second_ref_frame == GOLDEN_FRAME)
|
2012-07-14 00:21:29 +02:00
|
|
|
second_ref_fb_idx = cpi->common.gld_fb_idx;
|
|
|
|
else
|
|
|
|
second_ref_fb_idx = cpi->common.alt_fb_idx;
|
|
|
|
|
|
|
|
xd->second_pre.y_buffer = cpi->common.yv12_fb[second_ref_fb_idx].y_buffer +
|
|
|
|
recon_yoffset;
|
|
|
|
xd->second_pre.u_buffer = cpi->common.yv12_fb[second_ref_fb_idx].u_buffer +
|
|
|
|
recon_uvoffset;
|
|
|
|
xd->second_pre.v_buffer = cpi->common.yv12_fb[second_ref_fb_idx].v_buffer +
|
|
|
|
recon_uvoffset;
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!x->skip) {
|
|
|
|
vp8_encode_inter16x16(IF_RTCD(&cpi->rtcd), x);
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Clear mb_skip_coeff if mb_no_coeff_skip is not set
|
|
|
|
if (!cpi->common.mb_no_coeff_skip)
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->mb_skip_coeff = 0;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-09 02:12:12 +02:00
|
|
|
vp8_build_1st_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
|
|
|
|
xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.y_stride,
|
|
|
|
xd->dst.uv_stride);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!x->skip) {
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef ENC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
if (enc_debug) {
|
|
|
|
int i;
|
2012-08-10 15:12:43 +02:00
|
|
|
printf("Segment=%d [%d, %d]: %d %d:\n", mbmi->segment_id, mb_col_debug,
|
|
|
|
mb_row_debug, xd->mb_to_left_edge, xd->mb_to_top_edge);
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 0; i < 400; i++) {
|
|
|
|
printf("%3d ", xd->qcoeff[i]);
|
|
|
|
if (i % 16 == 15) printf("\n");
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
printf("eobs = ");
|
|
|
|
for (i = 0; i < 25; i++)
|
|
|
|
printf("%d:%d ", i, xd->block[i].eob);
|
|
|
|
printf("\n");
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
2011-02-14 23:18:18 +01:00
|
|
|
#endif
|
2012-08-06 19:51:20 +02:00
|
|
|
|
|
|
|
vp8_tokenize_mb(cpi, xd, t, !output_enabled);
|
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
#ifdef ENC_DEBUG
|
2012-07-14 00:21:29 +02:00
|
|
|
if (enc_debug) {
|
|
|
|
printf("Tokenized\n");
|
|
|
|
fflush(stdout);
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
int mb_skip_context =
|
|
|
|
cpi->common.mb_no_coeff_skip ?
|
|
|
|
(x->e_mbd.mode_info_context - 1)->mbmi.mb_skip_coeff +
|
|
|
|
(x->e_mbd.mode_info_context - cpi->common.mode_info_stride)->mbmi.mb_skip_coeff :
|
|
|
|
0;
|
|
|
|
if (cpi->common.mb_no_coeff_skip) {
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->mb_skip_coeff = 1;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (output_enabled)
|
|
|
|
cpi->skip_true_count[mb_skip_context]++;
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_fix_contexts(xd);
|
|
|
|
} else {
|
2012-08-06 19:51:20 +02:00
|
|
|
vp8_stuff_mb(cpi, xd, t, !output_enabled);
|
2012-08-10 15:12:43 +02:00
|
|
|
mbmi->mb_skip_coeff = 0;
|
2012-08-06 19:51:20 +02:00
|
|
|
if (output_enabled)
|
|
|
|
cpi->skip_false_count[mb_skip_context]++;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
|
|
void vp8cx_encode_inter_superblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
|
|
|
|
int recon_yoffset, int recon_uvoffset, int mb_col, int mb_row) {
|
|
|
|
const int output_enabled = 1;
|
|
|
|
VP8_COMMON *cm = &cpi->common;
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
2012-08-21 02:45:36 +02:00
|
|
|
const uint8_t *src = x->src.y_buffer;
|
|
|
|
uint8_t *dst = xd->dst.y_buffer;
|
|
|
|
const uint8_t *usrc = x->src.u_buffer;
|
|
|
|
uint8_t *udst = xd->dst.u_buffer;
|
|
|
|
const uint8_t *vsrc = x->src.v_buffer;
|
|
|
|
uint8_t *vdst = xd->dst.v_buffer;
|
2012-08-20 23:43:34 +02:00
|
|
|
int src_y_stride = x->src.y_stride, dst_y_stride = xd->dst.y_stride;
|
|
|
|
int src_uv_stride = x->src.uv_stride, dst_uv_stride = xd->dst.uv_stride;
|
|
|
|
const VP8_ENCODER_RTCD *rtcd = IF_RTCD(&cpi->rtcd);
|
|
|
|
unsigned int segment_id = xd->mode_info_context->mbmi.segment_id;
|
|
|
|
int seg_ref_active;
|
|
|
|
unsigned char ref_pred_flag;
|
|
|
|
int n;
|
|
|
|
TOKENEXTRA *tp[4];
|
|
|
|
int skip[4];
|
|
|
|
MODE_INFO *mi = x->e_mbd.mode_info_context;
|
|
|
|
ENTROPY_CONTEXT_PLANES ta[4], tl[4];
|
|
|
|
|
|
|
|
x->skip = 0;
|
|
|
|
|
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
// Adjust the zbin based on this MB rate.
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
// Experimental code. Special case for gf and arf zeromv modes.
|
|
|
|
// Increase zbin size to suppress noise
|
|
|
|
cpi->zbin_mode_boost = 0;
|
|
|
|
if (cpi->zbin_mode_boost_enabled) {
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME) {
|
|
|
|
if (xd->mode_info_context->mbmi.mode == ZEROMV) {
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame != LAST_FRAME)
|
|
|
|
cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
|
|
|
|
else
|
|
|
|
cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
|
|
|
|
} else if (xd->mode_info_context->mbmi.mode == SPLITMV)
|
|
|
|
cpi->zbin_mode_boost = 0;
|
|
|
|
else
|
|
|
|
cpi->zbin_mode_boost = MV_ZBIN_BOOST;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vp8_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
seg_ref_active = segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME);
|
|
|
|
|
|
|
|
// SET VARIOUS PREDICTION FLAGS
|
|
|
|
|
|
|
|
// Did the chosen reference frame match its predicted value.
|
|
|
|
ref_pred_flag = ((xd->mode_info_context->mbmi.ref_frame ==
|
|
|
|
get_pred_ref(cm, xd)));
|
|
|
|
set_pred_flag(xd, PRED_REF, ref_pred_flag);
|
|
|
|
|
|
|
|
/* test code: set transform size based on mode selection */
|
|
|
|
if (cpi->common.txfm_mode == ALLOW_8X8
|
|
|
|
&& x->e_mbd.mode_info_context->mbmi.mode != I8X8_PRED
|
|
|
|
&& x->e_mbd.mode_info_context->mbmi.mode != B_PRED
|
|
|
|
&& x->e_mbd.mode_info_context->mbmi.mode != SPLITMV) {
|
|
|
|
x->e_mbd.mode_info_context->mbmi.txfm_size = TX_8X8;
|
|
|
|
cpi->t8x8_count++;
|
|
|
|
} else {
|
|
|
|
x->e_mbd.mode_info_context->mbmi.txfm_size = TX_4X4;
|
|
|
|
cpi->t4x4_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
|
|
|
|
RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sby_s)(&x->e_mbd);
|
|
|
|
RECON_INVOKE(&rtcd->common->recon, build_intra_predictors_sbuv_s)(&x->e_mbd);
|
|
|
|
} else {
|
|
|
|
int ref_fb_idx;
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
|
|
|
|
ref_fb_idx = cpi->common.lst_fb_idx;
|
|
|
|
else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
|
|
|
|
ref_fb_idx = cpi->common.gld_fb_idx;
|
|
|
|
else
|
|
|
|
ref_fb_idx = cpi->common.alt_fb_idx;
|
|
|
|
|
|
|
|
xd->pre.y_buffer = cpi->common.yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
|
|
|
|
xd->pre.u_buffer = cpi->common.yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
|
|
|
|
xd->pre.v_buffer = cpi->common.yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame) {
|
|
|
|
int second_ref_fb_idx;
|
|
|
|
|
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame == LAST_FRAME)
|
|
|
|
second_ref_fb_idx = cpi->common.lst_fb_idx;
|
|
|
|
else if (xd->mode_info_context->mbmi.second_ref_frame == GOLDEN_FRAME)
|
|
|
|
second_ref_fb_idx = cpi->common.gld_fb_idx;
|
|
|
|
else
|
|
|
|
second_ref_fb_idx = cpi->common.alt_fb_idx;
|
|
|
|
|
|
|
|
xd->second_pre.y_buffer = cpi->common.yv12_fb[second_ref_fb_idx].y_buffer +
|
|
|
|
recon_yoffset;
|
|
|
|
xd->second_pre.u_buffer = cpi->common.yv12_fb[second_ref_fb_idx].u_buffer +
|
|
|
|
recon_uvoffset;
|
|
|
|
xd->second_pre.v_buffer = cpi->common.yv12_fb[second_ref_fb_idx].v_buffer +
|
|
|
|
recon_uvoffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
vp8_build_inter32x32_predictors_sb(xd, xd->dst.y_buffer,
|
|
|
|
xd->dst.u_buffer, xd->dst.v_buffer,
|
|
|
|
xd->dst.y_stride, xd->dst.uv_stride);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(x->e_mbd.mode_info_context->mbmi.txfm_size == TX_8X8);
|
|
|
|
for (n = 0; n < 4; n++)
|
|
|
|
{
|
|
|
|
int x_idx = n & 1, y_idx = n >> 1;
|
|
|
|
|
|
|
|
vp8_subtract_mby_s_c(x->src_diff,
|
|
|
|
src + x_idx * 16 + y_idx * 16 * src_y_stride,
|
|
|
|
src_y_stride,
|
|
|
|
dst + x_idx * 16 + y_idx * 16 * dst_y_stride,
|
|
|
|
dst_y_stride);
|
|
|
|
vp8_subtract_mbuv_s_c(x->src_diff,
|
|
|
|
usrc + x_idx * 8 + y_idx * 8 * src_uv_stride,
|
|
|
|
vsrc + x_idx * 8 + y_idx * 8 * src_uv_stride,
|
|
|
|
src_uv_stride,
|
|
|
|
udst + x_idx * 8 + y_idx * 8 * dst_uv_stride,
|
|
|
|
vdst + x_idx * 8 + y_idx * 8 * dst_uv_stride,
|
|
|
|
dst_uv_stride);
|
|
|
|
if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
|
|
|
|
vp8_transform_intra_mby_8x8(x);
|
|
|
|
} else {
|
|
|
|
vp8_transform_mby_8x8(x);
|
|
|
|
}
|
|
|
|
vp8_transform_mbuv_8x8(x);
|
|
|
|
vp8_quantize_mby_8x8(x);
|
|
|
|
vp8_quantize_mbuv_8x8(x);
|
|
|
|
if (x->optimize) {
|
|
|
|
vp8_optimize_mby_8x8(x, rtcd);
|
|
|
|
vp8_optimize_mbuv_8x8(x, rtcd);
|
|
|
|
}
|
|
|
|
vp8_inverse_transform_mby_8x8(IF_RTCD(&rtcd->common->idct), &x->e_mbd);
|
|
|
|
vp8_inverse_transform_mbuv_8x8(IF_RTCD(&rtcd->common->idct), &x->e_mbd);
|
|
|
|
vp8_recon_mby_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd,
|
|
|
|
dst + x_idx * 16 + y_idx * 16 * dst_y_stride);
|
|
|
|
vp8_recon_mbuv_s_c(IF_RTCD(&rtcd->common->recon), &x->e_mbd,
|
|
|
|
udst + x_idx * 8 + y_idx * 8 * dst_uv_stride,
|
|
|
|
vdst + x_idx * 8 + y_idx * 8 * dst_uv_stride);
|
|
|
|
|
|
|
|
if (!x->skip) {
|
|
|
|
if (output_enabled) {
|
|
|
|
xd->left_context = cm->left_context + (n >> 1);
|
|
|
|
xd->above_context = cm->above_context + mb_col + (n >> 1);
|
|
|
|
memcpy(&ta[n], xd->above_context, sizeof(ta[n]));
|
|
|
|
memcpy(&tl[n], xd->left_context, sizeof(tl[n]));
|
|
|
|
tp[n] = *t;
|
|
|
|
xd->mode_info_context = mi + x_idx + y_idx * cm->mode_info_stride;
|
|
|
|
vp8_tokenize_mb(cpi, &x->e_mbd, t, 0);
|
|
|
|
skip[n] = xd->mode_info_context->mbmi.mb_skip_coeff;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
int mb_skip_context =
|
|
|
|
cpi->common.mb_no_coeff_skip ?
|
|
|
|
(x->e_mbd.mode_info_context - 1)->mbmi.mb_skip_coeff +
|
|
|
|
(x->e_mbd.mode_info_context - cpi->common.mode_info_stride)->mbmi.mb_skip_coeff :
|
|
|
|
0;
|
|
|
|
if (cpi->common.mb_no_coeff_skip) {
|
|
|
|
skip[n] = xd->mode_info_context->mbmi.mb_skip_coeff = 1;
|
|
|
|
xd->left_context = cm->left_context + (n >> 1);
|
|
|
|
xd->above_context = cm->above_context + mb_col + (n >> 1);
|
|
|
|
memcpy(&ta[n], xd->above_context, sizeof(ta[n]));
|
|
|
|
memcpy(&tl[n], xd->left_context, sizeof(tl[n]));
|
|
|
|
tp[n] = *t;
|
|
|
|
cpi->skip_true_count[mb_skip_context]++;
|
|
|
|
vp8_fix_contexts(xd);
|
|
|
|
} else {
|
|
|
|
vp8_stuff_mb(cpi, xd, t, 0);
|
|
|
|
xd->mode_info_context->mbmi.mb_skip_coeff = 0;
|
|
|
|
cpi->skip_false_count[mb_skip_context]++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
xd->mode_info_context = mi;
|
|
|
|
update_sb_skip_coeff_state(cpi, x, ta, tl, tp, t, skip);
|
|
|
|
}
|
|
|
|
#endif
|