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
|
|
|
*/
|
|
|
|
|
|
|
|
|
2012-12-23 16:20:10 +01:00
|
|
|
#include "./vpx_config.h"
|
2013-05-31 00:13:08 +02:00
|
|
|
#include "./vp9_rtcd.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/encoder/vp9_encodeframe.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_encodemb.h"
|
|
|
|
#include "vp9/encoder/vp9_encodemv.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_common.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_onyx_int.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_extend.h"
|
2012-11-29 00:15:51 +01:00
|
|
|
#include "vp9/common/vp9_entropy.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_entropymode.h"
|
|
|
|
#include "vp9/common/vp9_quant_common.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_segmentation.h"
|
|
|
|
#include "vp9/encoder/vp9_encodeintra.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_reconinter.h"
|
|
|
|
#include "vp9/common/vp9_invtrans.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_rdopt.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_findnearmv.h"
|
|
|
|
#include "vp9/common/vp9_reconintra.h"
|
|
|
|
#include "vp9/common/vp9_seg_common.h"
|
2013-02-07 00:30:21 +01:00
|
|
|
#include "vp9/common/vp9_tile_common.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/encoder/vp9_tokenize.h"
|
2013-02-13 23:22:15 +01:00
|
|
|
#include "./vp9_rtcd.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>
|
|
|
|
#include "vpx_ports/vpx_timer.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_pred_common.h"
|
|
|
|
#include "vp9/common/vp9_mvref_common.h"
|
2012-08-24 16:44:01 +02:00
|
|
|
|
2012-11-07 19:41:04 +01:00
|
|
|
#define DBG_PRNT_SEGMAP 0
|
2010-09-24 00:25:33 +02:00
|
|
|
|
2012-11-16 00:14:38 +01:00
|
|
|
// #define ENC_DEBUG
|
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
|
|
|
#endif
|
|
|
|
|
2013-02-28 22:18:02 +01:00
|
|
|
void vp9_select_interp_filter_type(VP9_COMP *cpi);
|
2012-12-20 23:56:19 +01:00
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t,
|
2013-04-26 20:57:17 +02:00
|
|
|
int output_enabled, int mi_row, int mi_col,
|
2013-04-10 06:28:27 +02:00
|
|
|
BLOCK_SIZE_TYPE bsize);
|
2012-10-30 22:25:33 +01:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
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
|
2012-10-30 20:58:42 +01:00
|
|
|
* vp9_activity_masking().
|
2010-10-11 23:37:27 +02:00
|
|
|
*/
|
2012-10-31 22:40:53 +01:00
|
|
|
#define VP9_ACTIVITY_AVG_MIN (64)
|
2010-10-11 23:37:27 +02:00
|
|
|
|
|
|
|
/* 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-12-19 00:31:19 +01:00
|
|
|
static const uint8_t VP9_VAR_OFFS[16] = {
|
2012-07-14 00:21:29 +02:00
|
|
|
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-10-31 01:53:32 +01:00
|
|
|
static unsigned int tt_activity_measure(VP9_COMP *cpi, MACROBLOCK *x) {
|
2012-07-14 00:21:29 +02:00
|
|
|
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.).
|
|
|
|
*/
|
2013-04-24 01:22:47 +02:00
|
|
|
act = vp9_variance16x16(x->plane[0].src.buf, x->plane[0].src.stride,
|
|
|
|
VP9_VAR_OFFS, 0, &sse);
|
2013-02-28 22:18:02 +01:00
|
|
|
act <<= 4;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
/* 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-10-31 01:53:32 +01:00
|
|
|
static unsigned int alt_activity_measure(VP9_COMP *cpi,
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCK *x, int use_dc_pred) {
|
2012-10-30 20:58:42 +01:00
|
|
|
return vp9_encode_intra(cpi, x, use_dc_pred);
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
DECLARE_ALIGNED(16, static const uint8_t, vp9_64x64_zeros[64*64]) = { 0 };
|
|
|
|
|
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-10-31 01:53:32 +01:00
|
|
|
static unsigned int mb_activity_measure(VP9_COMP *cpi, MACROBLOCK *x,
|
2012-07-14 00:21:29 +02:00
|
|
|
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-10-31 22:40:53 +01:00
|
|
|
if (mb_activity < VP9_ACTIVITY_AVG_MIN)
|
|
|
|
mb_activity = VP9_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-10-31 01:53:32 +01:00
|
|
|
static void calc_av_activity(VP9_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-10-31 22:40:53 +01:00
|
|
|
if (cpi->activity_avg < VP9_ACTIVITY_AVG_MIN)
|
|
|
|
cpi->activity_avg = VP9_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
|
2013-03-26 14:11:52 +01:00
|
|
|
// Calculate an activity index for each mb
|
2012-10-31 01:53:32 +01:00
|
|
|
static void calc_activity_index(VP9_COMP *cpi, MACROBLOCK *x) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2012-07-14 00:21:29 +02:00
|
|
|
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-10-31 01:53:32 +01:00
|
|
|
static void build_activity_map(VP9_COMP *cpi) {
|
2012-10-17 23:51:27 +02:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_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
|
|
|
|
2013-03-26 14:11:52 +01:00
|
|
|
x->mb_activity_ptr = cpi->mb_activity_map;
|
|
|
|
|
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
|
2013-04-20 00:52:17 +02:00
|
|
|
xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->left_available = (mb_col != 0);
|
|
|
|
recon_yoffset += 16;
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
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
|
2013-04-24 01:22:47 +02:00
|
|
|
x->plane[0].src.buf += 16;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
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
|
2013-04-24 01:22:47 +02:00
|
|
|
x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
|
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-10-31 01:53:32 +01:00
|
|
|
void vp9_activity_masking(VP9_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
|
|
|
|
2013-01-07 20:41:49 +01:00
|
|
|
static void update_state(VP9_COMP *cpi,
|
2013-04-10 06:28:27 +02:00
|
|
|
PICK_MODE_CONTEXT *ctx,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
2013-01-06 03:20:25 +01:00
|
|
|
int output_enabled) {
|
|
|
|
int i, x_idx, y;
|
2013-01-07 20:41:49 +01:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2012-07-14 00:21:29 +02:00
|
|
|
MODE_INFO *mi = &ctx->mic;
|
2013-01-06 03:20:25 +01:00
|
|
|
MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
|
2013-05-30 21:49:38 +02:00
|
|
|
#if CONFIG_DEBUG || CONFIG_INTERNAL_STATS
|
|
|
|
MB_PREDICTION_MODE mb_mode = mi->mbmi.mode;
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
int mb_mode_index = ctx->best_mode_index;
|
2013-01-06 03:20:25 +01:00
|
|
|
const int mis = cpi->common.mode_info_stride;
|
2013-04-26 20:57:17 +02:00
|
|
|
const int bh = 1 << mi_height_log2(bsize), bw = 1 << mi_width_log2(bsize);
|
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);
|
2013-06-06 22:44:34 +02:00
|
|
|
assert(mi->mbmi.ref_frame[0] < MAX_REF_FRAMES);
|
|
|
|
assert(mi->mbmi.ref_frame[1] < MAX_REF_FRAMES);
|
2012-04-07 01:38:34 +02:00
|
|
|
#endif
|
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
assert(mi->mbmi.sb_type == bsize);
|
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
|
2013-04-10 06:28:27 +02:00
|
|
|
for (y = 0; y < bh; y++) {
|
|
|
|
for (x_idx = 0; x_idx < bw; x_idx++) {
|
2013-04-26 20:57:17 +02:00
|
|
|
if ((xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE)) + bw > x_idx &&
|
|
|
|
(xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE)) + bh > y) {
|
2013-01-06 03:20:25 +01:00
|
|
|
MODE_INFO *mi_addr = xd->mode_info_context + x_idx + y * mis;
|
2013-06-01 01:00:32 +02:00
|
|
|
*mi_addr = *mi;
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
2012-10-30 01:58:18 +01:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
2013-04-10 06:28:27 +02:00
|
|
|
if (bsize < BLOCK_SIZE_SB32X32) {
|
2013-05-01 01:13:20 +02:00
|
|
|
if (bsize < BLOCK_SIZE_MB16X16)
|
|
|
|
ctx->txfm_rd_diff[ALLOW_16X16] = ctx->txfm_rd_diff[ALLOW_8X8];
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
ctx->txfm_rd_diff[ALLOW_32X32] = ctx->txfm_rd_diff[ALLOW_16X16];
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[0] != INTRA_FRAME && mbmi->sb_type < BLOCK_SIZE_SB8X8) {
|
2013-06-01 01:00:32 +02:00
|
|
|
*x->partition_info = ctx->partition_info;
|
|
|
|
mbmi->mv[0].as_int = x->partition_info->bmi[3].mv.as_int;
|
|
|
|
mbmi->mv[1].as_int = x->partition_info->bmi[3].second_mv.as_int;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
2013-01-07 20:02:14 +01:00
|
|
|
x->skip = ctx->skip;
|
2013-01-06 03:20:25 +01:00
|
|
|
if (!output_enabled)
|
|
|
|
return;
|
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
if (!vp9_segfeature_active(xd, mbmi->segment_id, SEG_LVL_SKIP)) {
|
|
|
|
for (i = 0; i < NB_TXFM_MODES; i++) {
|
|
|
|
cpi->rd_tx_select_diff[i] += ctx->txfm_rd_diff[i];
|
2013-04-12 02:13:02 +02:00
|
|
|
}
|
2012-10-09 18:18:21 +02:00
|
|
|
}
|
|
|
|
|
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
|
2013-04-11 21:16:35 +02:00
|
|
|
// if (mb_mode == I4X4_PRED)
|
2012-07-14 00:21:29 +02:00
|
|
|
// 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*/,
|
2013-04-11 21:16:35 +02:00
|
|
|
THR_B_PRED /*I4X4_PRED*/,
|
2012-07-14 00:21:29 +02:00
|
|
|
};
|
|
|
|
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]++;
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[0] != INTRA_FRAME &&
|
2013-05-30 21:49:38 +02:00
|
|
|
(mbmi->sb_type < BLOCK_SIZE_SB8X8 || mbmi->mode == NEWMV)) {
|
2012-11-09 19:52:08 +01:00
|
|
|
int_mv best_mv, best_second_mv;
|
2013-06-06 22:44:34 +02:00
|
|
|
const MV_REFERENCE_FRAME rf1 = mbmi->ref_frame[0];
|
|
|
|
const MV_REFERENCE_FRAME rf2 = mbmi->ref_frame[1];
|
2012-11-09 19:52:08 +01:00
|
|
|
best_mv.as_int = ctx->best_ref_mv.as_int;
|
|
|
|
best_second_mv.as_int = ctx->second_best_ref_mv.as_int;
|
|
|
|
if (mbmi->mode == NEWMV) {
|
2013-06-06 22:44:34 +02:00
|
|
|
best_mv.as_int = mbmi->ref_mvs[rf1][0].as_int;
|
|
|
|
best_second_mv.as_int = mbmi->ref_mvs[rf2][0].as_int;
|
2012-11-09 19:52:08 +01:00
|
|
|
}
|
|
|
|
mbmi->best_mv.as_int = best_mv.as_int;
|
|
|
|
mbmi->best_second_mv.as_int = best_second_mv.as_int;
|
|
|
|
vp9_update_nmv_count(cpi, x, &best_mv, &best_second_mv);
|
2013-05-02 23:38:01 +02:00
|
|
|
}
|
2013-05-05 07:09:43 +02:00
|
|
|
|
2013-05-02 23:38:01 +02:00
|
|
|
if (bsize > BLOCK_SIZE_SB8X8 && mbmi->mode == NEWMV) {
|
|
|
|
int i, j;
|
|
|
|
for (j = 0; j < bh; ++j)
|
|
|
|
for (i = 0; i < bw; ++i)
|
2013-06-07 07:25:13 +02:00
|
|
|
if ((xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE)) + bw > i &&
|
|
|
|
(xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE)) + bh > j)
|
2013-06-06 15:07:09 +02:00
|
|
|
xd->mode_info_context[mis * j + i].mbmi = *mbmi;
|
2012-11-09 19:52:08 +01:00
|
|
|
}
|
2013-05-07 17:42:21 +02:00
|
|
|
|
2012-11-30 01:39:15 +01:00
|
|
|
if (cpi->common.mcomp_filter_type == SWITCHABLE &&
|
2013-04-24 21:14:58 +02:00
|
|
|
is_inter_mode(mbmi->mode)) {
|
2013-06-05 00:25:16 +02:00
|
|
|
++cpi->common.fc.switchable_interp_count
|
2012-11-30 01:39:15 +01:00
|
|
|
[vp9_get_pred_context(&cpi->common, xd, PRED_SWITCHABLE_INTERP)]
|
|
|
|
[vp9_switchable_interp_map[mbmi->interp_filter]];
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2012-11-08 20:03:00 +01:00
|
|
|
cpi->rd_comp_pred_diff[SINGLE_PREDICTION_ONLY] += ctx->single_pred_diff;
|
|
|
|
cpi->rd_comp_pred_diff[COMP_PREDICTION_ONLY] += ctx->comp_pred_diff;
|
|
|
|
cpi->rd_comp_pred_diff[HYBRID_PREDICTION] += ctx->hybrid_pred_diff;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
static unsigned find_seg_id(uint8_t *buf, BLOCK_SIZE_TYPE bsize,
|
2013-01-06 03:20:25 +01:00
|
|
|
int start_y, int height, int start_x, int width) {
|
2013-04-26 20:57:17 +02:00
|
|
|
const int bw = 1 << mi_width_log2(bsize), bh = 1 << mi_height_log2(bsize);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int end_x = MIN(start_x + bw, width);
|
|
|
|
const int end_y = MIN(start_y + bh, height);
|
2013-01-06 03:20:25 +01:00
|
|
|
int x, y;
|
|
|
|
unsigned seg_id = -1;
|
|
|
|
|
|
|
|
buf += width * start_y;
|
|
|
|
for (y = start_y; y < end_y; y++, buf += width) {
|
|
|
|
for (x = start_x; x < end_x; x++) {
|
|
|
|
seg_id = MIN(seg_id, buf[x]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return seg_id;
|
|
|
|
}
|
|
|
|
|
2013-04-24 01:22:47 +02:00
|
|
|
void vp9_setup_src_planes(MACROBLOCK *x,
|
|
|
|
const YV12_BUFFER_CONFIG *src,
|
|
|
|
int mb_row, int mb_col) {
|
2013-05-16 02:55:08 +02:00
|
|
|
uint8_t *buffers[4] = {src->y_buffer, src->u_buffer, src->v_buffer,
|
|
|
|
src->alpha_buffer};
|
|
|
|
int strides[4] = {src->y_stride, src->uv_stride, src->uv_stride,
|
|
|
|
src->alpha_stride};
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_MB_PLANE; i++) {
|
|
|
|
setup_pred_plane(&x->plane[i].src,
|
|
|
|
buffers[i], strides[i],
|
|
|
|
mb_row, mb_col, NULL,
|
|
|
|
x->e_mbd.plane[i].subsampling_x,
|
|
|
|
x->e_mbd.plane[i].subsampling_y);
|
|
|
|
}
|
2013-04-24 01:22:47 +02:00
|
|
|
}
|
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
static void set_offsets(VP9_COMP *cpi,
|
2013-04-26 20:57:17 +02:00
|
|
|
int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize) {
|
2013-01-06 03:20:25 +01:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
MB_MODE_INFO *mbmi;
|
|
|
|
const int dst_fb_idx = cm->new_fb_idx;
|
2013-04-26 20:57:17 +02:00
|
|
|
const int idx_str = xd->mode_info_stride * mi_row + mi_col;
|
|
|
|
const int bw = 1 << mi_width_log2(bsize), bh = 1 << mi_height_log2(bsize);
|
2013-05-05 07:09:43 +02:00
|
|
|
const int mb_row = mi_row >> 1;
|
|
|
|
const int mb_col = mi_col >> 1;
|
2013-01-06 03:20:25 +01:00
|
|
|
const int idx_map = mb_row * cm->mb_cols + mb_col;
|
2013-04-29 19:37:25 +02:00
|
|
|
int i;
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
// entropy context structures
|
2013-04-29 19:37:25 +02:00
|
|
|
for (i = 0; i < MAX_MB_PLANE; i++) {
|
|
|
|
xd->plane[i].above_context = cm->above_context[i] +
|
2013-05-05 07:09:43 +02:00
|
|
|
(mi_col * 2 >> xd->plane[i].subsampling_x);
|
2013-04-29 19:37:25 +02:00
|
|
|
xd->plane[i].left_context = cm->left_context[i] +
|
2013-05-05 07:09:43 +02:00
|
|
|
(((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
|
2013-04-29 19:37:25 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2013-04-23 19:12:18 +02:00
|
|
|
// partition contexts
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
// Activity map pointer
|
|
|
|
x->mb_activity_ptr = &cpi->mb_activity_map[idx_map];
|
|
|
|
x->active_ptr = cpi->active_map + idx_map;
|
|
|
|
|
|
|
|
/* pointers to mode info contexts */
|
|
|
|
x->partition_info = x->pi + idx_str;
|
|
|
|
xd->mode_info_context = cm->mi + idx_str;
|
|
|
|
mbmi = &xd->mode_info_context->mbmi;
|
2013-05-29 22:42:23 +02:00
|
|
|
// Special case: if prev_mi is NULL, the previous mode info context
|
|
|
|
// cannot be used.
|
|
|
|
xd->prev_mode_info_context = cm->prev_mi ?
|
|
|
|
cm->prev_mi + idx_str : NULL;
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
// Set up destination pointers
|
2013-04-26 20:57:17 +02:00
|
|
|
setup_dst_planes(xd, &cm->yv12_fb[dst_fb_idx], mi_row, mi_col);
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
/* Set up limit values for MV components to prevent them from
|
|
|
|
* extending beyond the UMV borders assuming 16x16 block size */
|
2013-04-26 20:57:17 +02:00
|
|
|
x->mv_row_min = -((mi_row * MI_SIZE) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
|
|
|
|
x->mv_col_min = -((mi_col * MI_SIZE) + VP9BORDERINPIXELS - VP9_INTERP_EXTEND);
|
|
|
|
x->mv_row_max = ((cm->mi_rows - mi_row) * MI_SIZE +
|
|
|
|
(VP9BORDERINPIXELS - MI_SIZE * bh - VP9_INTERP_EXTEND));
|
|
|
|
x->mv_col_max = ((cm->mi_cols - mi_col) * MI_SIZE +
|
|
|
|
(VP9BORDERINPIXELS - MI_SIZE * bw - VP9_INTERP_EXTEND));
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
// Set up distance of MB to edge of frame in 1/8th pel units
|
2013-04-26 20:57:17 +02:00
|
|
|
assert(!(mi_col & (bw - 1)) && !(mi_row & (bh - 1)));
|
|
|
|
set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
/* set up source buffers */
|
2013-04-26 20:57:17 +02:00
|
|
|
vp9_setup_src_planes(x, cpi->Source, mi_row, mi_col);
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
/* R/D setup */
|
|
|
|
x->rddiv = cpi->RDDIV;
|
|
|
|
x->rdmult = cpi->RDMULT;
|
|
|
|
|
|
|
|
/* segment ID */
|
|
|
|
if (xd->segmentation_enabled) {
|
2013-04-30 01:07:17 +02:00
|
|
|
uint8_t *map = xd->update_mb_segmentation_map ? cpi->segmentation_map
|
|
|
|
: cm->last_frame_seg_map;
|
|
|
|
mbmi->segment_id = find_seg_id(map, bsize, mi_row,
|
|
|
|
cm->mi_rows, mi_col, cm->mi_cols);
|
|
|
|
|
2013-04-24 14:04:45 +02:00
|
|
|
assert(mbmi->segment_id <= (MAX_MB_SEGMENTS-1));
|
2013-01-06 03:20:25 +01:00
|
|
|
vp9_mb_init_quantizer(cpi, x);
|
|
|
|
|
|
|
|
if (xd->segmentation_enabled && cpi->seg0_cnt > 0 &&
|
|
|
|
!vp9_segfeature_active(xd, 0, SEG_LVL_REF_FRAME) &&
|
|
|
|
vp9_segfeature_active(xd, 1, SEG_LVL_REF_FRAME) &&
|
|
|
|
vp9_check_segref(xd, 1, INTRA_FRAME) +
|
|
|
|
vp9_check_segref(xd, 1, LAST_FRAME) +
|
|
|
|
vp9_check_segref(xd, 1, GOLDEN_FRAME) +
|
|
|
|
vp9_check_segref(xd, 1, ALTREF_FRAME) == 1) {
|
|
|
|
cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
|
|
|
|
} else {
|
|
|
|
const int y = mb_row & ~3;
|
|
|
|
const int x = mb_col & ~3;
|
|
|
|
const int p16 = ((mb_row & 1) << 1) + (mb_col & 1);
|
|
|
|
const int p32 = ((mb_row & 2) << 2) + ((mb_col & 2) << 1);
|
2013-04-26 20:57:17 +02:00
|
|
|
const int tile_progress =
|
2013-05-05 07:09:43 +02:00
|
|
|
cm->cur_tile_mi_col_start * cm->mb_rows >> 1;
|
2013-04-26 20:57:17 +02:00
|
|
|
const int mb_cols =
|
2013-05-05 07:09:43 +02:00
|
|
|
(cm->cur_tile_mi_col_end - cm->cur_tile_mi_col_start) >> 1;
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
cpi->seg0_progress =
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
((y * mb_cols + x * 4 + p32 + p16 + tile_progress) << 16) / cm->MBs;
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mbmi->segment_id = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
static void pick_sb_modes(VP9_COMP *cpi, int mi_row, int mi_col,
|
2013-04-11 18:33:49 +02:00
|
|
|
TOKENEXTRA **tp, int *totalrate, int *totaldist,
|
|
|
|
BLOCK_SIZE_TYPE bsize, PICK_MODE_CONTEXT *ctx) {
|
2013-01-07 20:41:49 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2012-08-20 23:43:34 +02:00
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize < BLOCK_SIZE_SB8X8)
|
|
|
|
if (xd->ab_index != 0)
|
|
|
|
return;
|
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
set_offsets(cpi, mi_row, mi_col, bsize);
|
2013-04-11 18:33:49 +02:00
|
|
|
xd->mode_info_context->mbmi.sb_type = bsize;
|
2013-01-06 03:20:25 +01:00
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
|
2012-10-30 20:58:42 +01:00
|
|
|
vp9_activity_masking(cpi, x);
|
2012-08-20 23:43:34 +02:00
|
|
|
|
|
|
|
/* Find best coding mode & reconstruct the MB so it is available
|
|
|
|
* as a predictor for MBs that follow in the SB */
|
2013-01-06 03:20:25 +01:00
|
|
|
if (cm->frame_type == KEY_FRAME) {
|
2013-04-11 18:33:49 +02:00
|
|
|
vp9_rd_pick_intra_mode_sb(cpi, x, totalrate, totaldist, bsize, ctx);
|
2013-01-06 03:20:25 +01:00
|
|
|
} else {
|
2013-04-26 20:57:17 +02:00
|
|
|
vp9_rd_pick_inter_mode_sb(cpi, x, mi_row, mi_col, totalrate, totaldist,
|
2013-04-11 18:33:49 +02:00
|
|
|
bsize, ctx);
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) {
|
2013-01-06 03:20:25 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
MODE_INFO *mi = xd->mode_info_context;
|
|
|
|
MB_MODE_INFO *const mbmi = &mi->mbmi;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-05-16 14:40:32 +02:00
|
|
|
if (cm->frame_type != KEY_FRAME) {
|
2013-01-06 03:20:25 +01:00
|
|
|
int segment_id, seg_ref_active;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
cpi->intra_inter_count[vp9_get_pred_context(cm, xd, PRED_INTRA_INTER)]
|
|
|
|
[mbmi->ref_frame[0] > INTRA_FRAME]++;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-01-06 03:20:25 +01: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.
|
|
|
|
segment_id = mbmi->segment_id;
|
|
|
|
seg_ref_active = vp9_segfeature_active(xd, segment_id,
|
|
|
|
SEG_LVL_REF_FRAME);
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[0] > INTRA_FRAME &&
|
|
|
|
(!seg_ref_active ||
|
|
|
|
((vp9_check_segref(xd, segment_id, INTRA_FRAME) +
|
|
|
|
vp9_check_segref(xd, segment_id, LAST_FRAME) +
|
|
|
|
vp9_check_segref(xd, segment_id, GOLDEN_FRAME) +
|
|
|
|
vp9_check_segref(xd, segment_id, ALTREF_FRAME)) > 1))) {
|
|
|
|
if (cm->comp_pred_mode == HYBRID_PREDICTION)
|
|
|
|
cpi->comp_inter_count[vp9_get_pred_context(cm, xd,
|
|
|
|
PRED_COMP_INTER_INTER)]
|
|
|
|
[mbmi->ref_frame[1] > INTRA_FRAME]++;
|
|
|
|
|
|
|
|
if (mbmi->ref_frame[1] > INTRA_FRAME) {
|
|
|
|
cpi->comp_ref_count[vp9_get_pred_context(cm, xd, PRED_COMP_REF_P)]
|
|
|
|
[mbmi->ref_frame[0] == GOLDEN_FRAME]++;
|
|
|
|
} else {
|
|
|
|
cpi->single_ref_count[vp9_get_pred_context(cm, xd, PRED_SINGLE_REF_P1)]
|
|
|
|
[0][mbmi->ref_frame[0] != LAST_FRAME]++;
|
|
|
|
if (mbmi->ref_frame[0] != LAST_FRAME)
|
|
|
|
cpi->single_ref_count[vp9_get_pred_context(cm, xd,
|
|
|
|
PRED_SINGLE_REF_P2)]
|
|
|
|
[1][mbmi->ref_frame[0] != GOLDEN_FRAME]++;
|
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
// Count of last ref frame 0,0 usage
|
2013-06-06 22:44:34 +02:00
|
|
|
if ((mbmi->mode == ZEROMV) && (mbmi->ref_frame[0] == LAST_FRAME))
|
2013-01-06 03:20:25 +01:00
|
|
|
cpi->inter_zz_count++;
|
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// TODO(jingning): the variables used here are little complicated. need further
|
|
|
|
// refactoring on organizing the the temporary buffers, when recursive
|
|
|
|
// partition down to 4x4 block size is enabled.
|
2013-04-28 17:59:13 +02:00
|
|
|
static PICK_MODE_CONTEXT *get_block_context(MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2012-08-20 23:43:34 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
switch (bsize) {
|
|
|
|
case BLOCK_SIZE_SB64X64:
|
|
|
|
return &x->sb64_context;
|
|
|
|
case BLOCK_SIZE_SB64X32:
|
|
|
|
return &x->sb64x32_context[xd->sb_index];
|
|
|
|
case BLOCK_SIZE_SB32X64:
|
|
|
|
return &x->sb32x64_context[xd->sb_index];
|
|
|
|
case BLOCK_SIZE_SB32X32:
|
|
|
|
return &x->sb32_context[xd->sb_index];
|
|
|
|
case BLOCK_SIZE_SB32X16:
|
|
|
|
return &x->sb32x16_context[xd->sb_index][xd->mb_index];
|
|
|
|
case BLOCK_SIZE_SB16X32:
|
|
|
|
return &x->sb16x32_context[xd->sb_index][xd->mb_index];
|
|
|
|
case BLOCK_SIZE_MB16X16:
|
|
|
|
return &x->mb_context[xd->sb_index][xd->mb_index];
|
2013-05-01 01:13:20 +02:00
|
|
|
case BLOCK_SIZE_SB16X8:
|
|
|
|
return &x->sb16x8_context[xd->sb_index][xd->mb_index][xd->b_index];
|
|
|
|
case BLOCK_SIZE_SB8X16:
|
|
|
|
return &x->sb8x16_context[xd->sb_index][xd->mb_index][xd->b_index];
|
|
|
|
case BLOCK_SIZE_SB8X8:
|
2013-05-11 02:06:37 +02:00
|
|
|
return &x->sb8x8_context[xd->sb_index][xd->mb_index][xd->b_index];
|
|
|
|
case BLOCK_SIZE_SB8X4:
|
|
|
|
return &x->sb8x4_context[xd->sb_index][xd->mb_index][xd->b_index];
|
|
|
|
case BLOCK_SIZE_SB4X8:
|
|
|
|
return &x->sb4x8_context[xd->sb_index][xd->mb_index][xd->b_index];
|
|
|
|
case BLOCK_SIZE_AB4X4:
|
|
|
|
return &x->ab4x4_context[xd->sb_index][xd->mb_index][xd->b_index];
|
2013-04-28 17:59:13 +02:00
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
static BLOCK_SIZE_TYPE *get_sb_partitioning(MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
switch (bsize) {
|
|
|
|
case BLOCK_SIZE_SB64X64:
|
|
|
|
return &x->sb64_partitioning;
|
|
|
|
case BLOCK_SIZE_SB32X32:
|
|
|
|
return &x->sb_partitioning[xd->sb_index];
|
|
|
|
case BLOCK_SIZE_MB16X16:
|
|
|
|
return &x->mb_partitioning[xd->sb_index][xd->mb_index];
|
2013-05-11 02:06:37 +02:00
|
|
|
case BLOCK_SIZE_SB8X8:
|
|
|
|
return &x->b_partitioning[xd->sb_index][xd->mb_index][xd->b_index];
|
2013-05-08 23:24:43 +02:00
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void restore_context(VP9_COMP *cpi, int mi_row, int mi_col,
|
|
|
|
ENTROPY_CONTEXT a[16 * MAX_MB_PLANE],
|
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE],
|
|
|
|
PARTITION_CONTEXT sa[8],
|
|
|
|
PARTITION_CONTEXT sl[8],
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
int p;
|
|
|
|
int bwl = b_width_log2(bsize), bw = 1 << bwl;
|
|
|
|
int bhl = b_height_log2(bsize), bh = 1 << bhl;
|
|
|
|
int mwl = mi_width_log2(bsize), mw = 1 << mwl;
|
|
|
|
int mhl = mi_height_log2(bsize), mh = 1 << mhl;
|
|
|
|
for (p = 0; p < MAX_MB_PLANE; p++) {
|
|
|
|
vpx_memcpy(cm->above_context[p] +
|
|
|
|
((mi_col * 2) >> xd->plane[p].subsampling_x),
|
|
|
|
a + bw * p,
|
|
|
|
sizeof(ENTROPY_CONTEXT) * bw >> xd->plane[p].subsampling_x);
|
|
|
|
vpx_memcpy(cm->left_context[p] +
|
|
|
|
((mi_row & MI_MASK) * 2 >> xd->plane[p].subsampling_y),
|
|
|
|
l + bh * p,
|
|
|
|
sizeof(ENTROPY_CONTEXT) * bh >> xd->plane[p].subsampling_y);
|
|
|
|
}
|
|
|
|
vpx_memcpy(cm->above_seg_context + mi_col, sa,
|
|
|
|
sizeof(PARTITION_CONTEXT) * mw);
|
|
|
|
vpx_memcpy(cm->left_seg_context + (mi_row & MI_MASK), sl,
|
|
|
|
sizeof(PARTITION_CONTEXT) * mh);
|
|
|
|
}
|
2013-05-31 00:13:08 +02:00
|
|
|
static void save_context(VP9_COMP *cpi, int mi_row, int mi_col,
|
|
|
|
ENTROPY_CONTEXT a[16 * MAX_MB_PLANE],
|
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE],
|
|
|
|
PARTITION_CONTEXT sa[8],
|
|
|
|
PARTITION_CONTEXT sl[8],
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
int p;
|
|
|
|
int bwl = b_width_log2(bsize), bw = 1 << bwl;
|
|
|
|
int bhl = b_height_log2(bsize), bh = 1 << bhl;
|
|
|
|
int mwl = mi_width_log2(bsize), mw = 1 << mwl;
|
|
|
|
int mhl = mi_height_log2(bsize), mh = 1 << mhl;
|
|
|
|
|
|
|
|
// buffer the above/left context information of the block in search.
|
|
|
|
for (p = 0; p < MAX_MB_PLANE; ++p) {
|
|
|
|
vpx_memcpy(a + bw * p, cm->above_context[p] +
|
|
|
|
(mi_col * 2 >> xd->plane[p].subsampling_x),
|
|
|
|
sizeof(ENTROPY_CONTEXT) * bw >> xd->plane[p].subsampling_x);
|
|
|
|
vpx_memcpy(l + bh * p, cm->left_context[p] +
|
|
|
|
((mi_row & MI_MASK) * 2 >> xd->plane[p].subsampling_y),
|
|
|
|
sizeof(ENTROPY_CONTEXT) * bh >> xd->plane[p].subsampling_y);
|
|
|
|
}
|
|
|
|
vpx_memcpy(sa, cm->above_seg_context + mi_col,
|
|
|
|
sizeof(PARTITION_CONTEXT) * mw);
|
|
|
|
vpx_memcpy(sl, cm->left_seg_context + (mi_row & MI_MASK),
|
|
|
|
sizeof(PARTITION_CONTEXT) * mh);
|
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
static void encode_b(VP9_COMP *cpi, TOKENEXTRA **tp,
|
|
|
|
int mi_row, int mi_col, int output_enabled,
|
|
|
|
BLOCK_SIZE_TYPE bsize, int sub_index) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (sub_index != -1)
|
2013-05-17 01:13:33 +02:00
|
|
|
*(get_sb_index(xd, bsize)) = sub_index;
|
2013-05-16 07:28:36 +02:00
|
|
|
|
|
|
|
if (bsize < BLOCK_SIZE_SB8X8)
|
|
|
|
if (xd->ab_index > 0)
|
|
|
|
return;
|
2013-04-28 17:59:13 +02:00
|
|
|
set_offsets(cpi, mi_row, mi_col, bsize);
|
|
|
|
update_state(cpi, get_block_context(x, bsize), bsize, output_enabled);
|
2013-05-05 07:09:43 +02:00
|
|
|
encode_superblock(cpi, tp, output_enabled, mi_row, mi_col, bsize);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (output_enabled) {
|
|
|
|
update_stats(cpi, mi_row, mi_col);
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
(*tp)->token = EOSB_TOKEN;
|
|
|
|
(*tp)++;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
static void encode_sb(VP9_COMP *cpi, TOKENEXTRA **tp,
|
|
|
|
int mi_row, int mi_col, int output_enabled,
|
2013-05-08 23:24:43 +02:00
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-01-07 20:41:49 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-05-08 23:24:43 +02:00
|
|
|
BLOCK_SIZE_TYPE c1 = BLOCK_SIZE_SB8X8;
|
2013-05-17 01:13:33 +02:00
|
|
|
const int bsl = b_width_log2(bsize), bs = (1 << bsl) / 4;
|
2013-05-08 23:24:43 +02:00
|
|
|
int bwl, bhl;
|
2013-05-01 01:13:20 +02:00
|
|
|
int UNINITIALIZED_IS_SAFE(pl);
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
2013-01-07 20:41:49 +01:00
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
c1 = BLOCK_SIZE_AB4X4;
|
2013-05-22 06:28:42 +02:00
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8) {
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-05-08 23:24:43 +02:00
|
|
|
pl = partition_plane_context(xd, bsize);
|
|
|
|
c1 = *(get_sb_partitioning(x, bsize));
|
2013-05-01 01:13:20 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2013-05-17 01:13:33 +02:00
|
|
|
bwl = b_width_log2(c1), bhl = b_height_log2(c1);
|
2013-05-08 23:24:43 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (bsl == bwl && bsl == bhl) {
|
2013-05-16 07:28:36 +02:00
|
|
|
if (output_enabled && bsize >= BLOCK_SIZE_SB8X8)
|
2013-05-11 02:06:37 +02:00
|
|
|
cpi->partition_count[pl][PARTITION_NONE]++;
|
2013-04-28 17:59:13 +02:00
|
|
|
encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, -1);
|
|
|
|
} else if (bsl == bhl && bsl > bwl) {
|
|
|
|
if (output_enabled)
|
|
|
|
cpi->partition_count[pl][PARTITION_VERT]++;
|
|
|
|
encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, 0);
|
|
|
|
encode_b(cpi, tp, mi_row, mi_col + bs, output_enabled, c1, 1);
|
|
|
|
} else if (bsl == bwl && bsl > bhl) {
|
|
|
|
if (output_enabled)
|
|
|
|
cpi->partition_count[pl][PARTITION_HORZ]++;
|
|
|
|
encode_b(cpi, tp, mi_row, mi_col, output_enabled, c1, 0);
|
|
|
|
encode_b(cpi, tp, mi_row + bs, mi_col, output_enabled, c1, 1);
|
|
|
|
} else {
|
|
|
|
BLOCK_SIZE_TYPE subsize;
|
2013-04-17 18:25:06 +02:00
|
|
|
int i;
|
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
assert(bwl < bsl && bhl < bsl);
|
2013-05-11 02:06:37 +02:00
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (output_enabled)
|
|
|
|
cpi->partition_count[pl][PARTITION_SPLIT]++;
|
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
for (i = 0; i < 4; i++) {
|
2013-04-28 17:59:13 +02:00
|
|
|
const int x_idx = i & 1, y_idx = i >> 1;
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2013-05-17 01:13:33 +02:00
|
|
|
*(get_sb_index(xd, subsize)) = i;
|
2013-04-28 17:59:13 +02:00
|
|
|
encode_sb(cpi, tp, mi_row + y_idx * bs, mi_col + x_idx * bs,
|
2013-05-08 23:24:43 +02:00
|
|
|
output_enabled, subsize);
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
}
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8 &&
|
|
|
|
(bsize == BLOCK_SIZE_SB8X8 || bsl == bwl || bsl == bhl)) {
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-05-08 23:24:43 +02:00
|
|
|
update_partition_context(xd, c1, bsize);
|
2013-04-23 19:12:18 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
static void set_partitioning(VP9_COMP *cpi, MODE_INFO *m,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
const int mis = cm->mode_info_stride;
|
|
|
|
int bsl = b_width_log2(bsize);
|
|
|
|
int bs = (1 << bsl) / 2; //
|
|
|
|
int block_row, block_col;
|
|
|
|
int row, col;
|
|
|
|
|
|
|
|
// this test function sets the entire macroblock to the same bsize
|
|
|
|
for (block_row = 0; block_row < 8; block_row += bs) {
|
|
|
|
for (block_col = 0; block_col < 8; block_col += bs) {
|
|
|
|
for (row = 0; row < bs; row++) {
|
|
|
|
for (col = 0; col < bs; col++) {
|
|
|
|
m[(block_row+row)*mis + block_col+col].mbmi.sb_type = bsize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_block_size(VP9_COMMON *const cm,
|
|
|
|
MODE_INFO *m, BLOCK_SIZE_TYPE bsize, int mis,
|
|
|
|
int mi_row, int mi_col) {
|
|
|
|
int row, col;
|
2013-06-06 15:07:09 +02:00
|
|
|
int bwl = b_width_log2(bsize);
|
|
|
|
int bhl = b_height_log2(bsize);
|
|
|
|
int bsl = (bwl > bhl ? bwl : bhl);
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
int bs = (1 << bsl) / 2; //
|
|
|
|
MODE_INFO *m2 = m + mi_row * mis + mi_col;
|
|
|
|
for (row = 0; row < bs; row++) {
|
|
|
|
for (col = 0; col < bs; col++) {
|
|
|
|
if (mi_row + row >= cm->mi_rows || mi_col + col >= cm->mi_cols)
|
2013-06-06 15:07:09 +02:00
|
|
|
continue;
|
2013-05-31 00:13:08 +02:00
|
|
|
m2[row*mis+col].mbmi.sb_type = bsize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
typedef struct {
|
|
|
|
int64_t sum_square_error;
|
|
|
|
int64_t sum_error;
|
|
|
|
int count;
|
|
|
|
int variance;
|
|
|
|
} var;
|
|
|
|
|
|
|
|
#define VT(TYPE, BLOCKSIZE) \
|
|
|
|
typedef struct { \
|
|
|
|
var none; \
|
|
|
|
var horz[2]; \
|
|
|
|
var vert[2]; \
|
|
|
|
BLOCKSIZE split[4]; } TYPE;
|
|
|
|
|
|
|
|
VT(v8x8, var)
|
|
|
|
VT(v16x16, v8x8)
|
|
|
|
VT(v32x32, v16x16)
|
|
|
|
VT(v64x64, v32x32)
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
V16X16,
|
|
|
|
V32X32,
|
|
|
|
V64X64,
|
|
|
|
} TREE_LEVEL;
|
|
|
|
|
|
|
|
// Set variance values given sum square error, sum error, count.
|
|
|
|
static void fill_variance(var *v, int64_t s2, int64_t s, int c) {
|
|
|
|
v->sum_square_error = s2;
|
|
|
|
v->sum_error = s;
|
|
|
|
v->count = c;
|
|
|
|
v->variance = 256
|
|
|
|
* (v->sum_square_error - v->sum_error * v->sum_error / v->count)
|
|
|
|
/ v->count;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Combine 2 variance structures by summing the sum_error, sum_square_error,
|
|
|
|
// and counts and then calculating the new variance.
|
|
|
|
void sum_2_variances(var *r, var *a, var*b) {
|
|
|
|
fill_variance(r, a->sum_square_error + b->sum_square_error,
|
|
|
|
a->sum_error + b->sum_error, a->count + b->count);
|
|
|
|
}
|
|
|
|
// Fill one level of our variance tree, by summing the split sums into each of
|
|
|
|
// the horizontal, vertical and none from split and recalculating variance.
|
|
|
|
#define fill_variance_tree(VT) \
|
|
|
|
sum_2_variances(VT.horz[0], VT.split[0].none, VT.split[1].none); \
|
|
|
|
sum_2_variances(VT.horz[1], VT.split[2].none, VT.split[3].none); \
|
|
|
|
sum_2_variances(VT.vert[0], VT.split[0].none, VT.split[2].none); \
|
|
|
|
sum_2_variances(VT.vert[1], VT.split[1].none, VT.split[3].none); \
|
|
|
|
sum_2_variances(VT.none, VT.vert[0], VT.vert[1]);
|
|
|
|
|
|
|
|
// Set the blocksize in the macroblock info structure if the variance is less
|
|
|
|
// than our threshold to one of none, horz, vert.
|
|
|
|
#define set_vt_size(VT, BLOCKSIZE, R, C, ACTION) \
|
|
|
|
if (VT.none.variance < threshold) { \
|
|
|
|
set_block_size(cm, m, BLOCKSIZE, mis, R, C); \
|
|
|
|
ACTION; \
|
|
|
|
} \
|
|
|
|
if (VT.horz[0].variance < threshold && VT.horz[1].variance < threshold ) { \
|
|
|
|
set_block_size(cm, m, get_subsize(BLOCKSIZE, PARTITION_HORZ), mis, R, C); \
|
|
|
|
ACTION; \
|
|
|
|
} \
|
|
|
|
if (VT.vert[0].variance < threshold && VT.vert[1].variance < threshold ) { \
|
|
|
|
set_block_size(cm, m, get_subsize(BLOCKSIZE, PARTITION_VERT), mis, R, C); \
|
|
|
|
ACTION; \
|
|
|
|
}
|
|
|
|
|
|
|
|
static void choose_partitioning(VP9_COMP *cpi, MODE_INFO *m, int mi_row,
|
|
|
|
int mi_col) {
|
|
|
|
VP9_COMMON * const cm = &cpi->common;
|
|
|
|
MACROBLOCK *x = &cpi->mb;
|
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
|
|
|
const int mis = cm->mode_info_stride;
|
|
|
|
// TODO(JBB): More experimentation or testing of this threshold;
|
|
|
|
int64_t threshold = 4;
|
|
|
|
int i, j, k;
|
|
|
|
v64x64 vt;
|
|
|
|
unsigned char * s;
|
|
|
|
int sp;
|
|
|
|
const unsigned char * d = xd->plane[0].pre->buf;
|
|
|
|
int dp = xd->plane[0].pre->stride;
|
2013-06-06 15:07:09 +02:00
|
|
|
int pixels_wide = 64, pixels_high = 64;
|
|
|
|
|
|
|
|
vpx_memset(&vt, 0, sizeof(vt));
|
2013-05-31 00:13:08 +02:00
|
|
|
|
|
|
|
set_offsets(cpi, mi_row, mi_col, BLOCK_SIZE_SB64X64);
|
2013-06-06 15:07:09 +02:00
|
|
|
|
|
|
|
if (xd->mb_to_right_edge < 0)
|
|
|
|
pixels_wide += (xd->mb_to_right_edge >> 3);
|
|
|
|
|
|
|
|
if (xd->mb_to_bottom_edge < 0)
|
|
|
|
pixels_high += (xd->mb_to_bottom_edge >> 3);
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
s = x->plane[0].src.buf;
|
|
|
|
sp = x->plane[0].src.stride;
|
|
|
|
|
|
|
|
// TODO(JBB): Clearly the higher the quantizer the fewer partitions we want
|
|
|
|
// but this needs more experimentation.
|
|
|
|
threshold = threshold * cpi->common.base_qindex * cpi->common.base_qindex;
|
|
|
|
|
|
|
|
// if ( cm->frame_type == KEY_FRAME ) {
|
|
|
|
d = vp9_64x64_zeros;
|
|
|
|
dp = 64;
|
|
|
|
// }
|
2013-06-06 15:07:09 +02:00
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
// Fill in the entire tree of 8x8 variances for splits.
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
const int x32_idx = ((i & 1) << 5);
|
|
|
|
const int y32_idx = ((i >> 1) << 5);
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
|
const int x_idx = x32_idx + ((j & 1) << 4);
|
|
|
|
const int y_idx = y32_idx + ((j >> 1) << 4);
|
2013-06-06 15:07:09 +02:00
|
|
|
const uint8_t *st = s + y_idx * sp + x_idx;
|
|
|
|
const uint8_t *dt = d + y_idx * dp + x_idx;
|
|
|
|
unsigned int sse = 0;
|
|
|
|
int sum = 0;
|
|
|
|
v16x16 *vst = &vt.split[i].split[j];
|
|
|
|
sse = sum = 0;
|
|
|
|
if (x_idx < pixels_wide && y_idx < pixels_high)
|
|
|
|
vp9_get_sse_sum_8x8(st, sp, dt, dp, &sse, &sum);
|
|
|
|
fill_variance(&vst->split[0].none, sse, sum, 64);
|
|
|
|
sse = sum = 0;
|
|
|
|
if (x_idx + 8 < pixels_wide && y_idx < pixels_high)
|
|
|
|
vp9_get_sse_sum_8x8(st + 8, sp, dt + 8, dp, &sse, &sum);
|
|
|
|
fill_variance(&vst->split[1].none, sse, sum, 64);
|
|
|
|
sse = sum = 0;
|
|
|
|
if (x_idx < pixels_wide && y_idx + 8 < pixels_high)
|
|
|
|
vp9_get_sse_sum_8x8(st + 8 * sp, sp, dt + 8 * dp, dp, &sse, &sum);
|
|
|
|
fill_variance(&vst->split[2].none, sse, sum, 64);
|
|
|
|
sse = sum = 0;
|
|
|
|
if (x_idx + 8 < pixels_wide && y_idx + 8 < pixels_high)
|
|
|
|
vp9_get_sse_sum_8x8(st + 8 * sp + 8, sp, dt + 8 + 8 * dp, dp, &sse,
|
|
|
|
&sum);
|
|
|
|
fill_variance(&vst->split[3].none, sse, sum, 64);
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Fill the rest of the variance tree by summing the split partition
|
|
|
|
// values.
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
|
fill_variance_tree(&vt.split[i].split[j])
|
|
|
|
}
|
|
|
|
fill_variance_tree(&vt.split[i])
|
|
|
|
}
|
|
|
|
fill_variance_tree(&vt)
|
|
|
|
|
|
|
|
// Now go through the entire structure, splitting every blocksize until
|
|
|
|
// we get to one that's got a variance lower than our threshold, or we
|
|
|
|
// hit 8x8.
|
|
|
|
set_vt_size( vt, BLOCK_SIZE_SB64X64, mi_row, mi_col, return);
|
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
const int x32_idx = ((i & 1) << 2);
|
|
|
|
const int y32_idx = ((i >> 1) << 2);
|
|
|
|
set_vt_size(vt, BLOCK_SIZE_SB32X32, mi_row + y32_idx, mi_col + x32_idx,
|
|
|
|
continue);
|
|
|
|
|
|
|
|
for (j = 0; j < 4; ++j) {
|
|
|
|
const int x16_idx = ((j & 1) << 1);
|
|
|
|
const int y16_idx = ((j >> 1) << 1);
|
|
|
|
set_vt_size(vt, BLOCK_SIZE_MB16X16, mi_row + y32_idx + y16_idx,
|
|
|
|
mi_col+x32_idx+x16_idx, continue);
|
|
|
|
|
|
|
|
for (k = 0; k < 4; ++k) {
|
|
|
|
const int x8_idx = (k & 1);
|
|
|
|
const int y8_idx = (k >> 1);
|
|
|
|
set_block_size(cm, m, BLOCK_SIZE_SB8X8, mis,
|
|
|
|
mi_row + y32_idx + y16_idx + y8_idx,
|
|
|
|
mi_col + x32_idx + x16_idx + x8_idx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void rd_use_partition(VP9_COMP *cpi, MODE_INFO *m, TOKENEXTRA **tp,
|
|
|
|
int mi_row, int mi_col, BLOCK_SIZE_TYPE bsize,
|
|
|
|
int *rate, int *dist) {
|
|
|
|
VP9_COMMON * const cm = &cpi->common;
|
|
|
|
MACROBLOCK * const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
|
|
|
const int mis = cm->mode_info_stride;
|
2013-06-06 15:07:09 +02:00
|
|
|
int bwl = b_width_log2(m->mbmi.sb_type);
|
|
|
|
int bhl = b_height_log2(m->mbmi.sb_type);
|
2013-05-31 00:13:08 +02:00
|
|
|
int bsl = b_width_log2(bsize);
|
2013-06-06 15:07:09 +02:00
|
|
|
int bh = (1 << bhl);
|
2013-05-31 00:13:08 +02:00
|
|
|
int bs = (1 << bsl);
|
|
|
|
int bss = (1 << bsl)/4;
|
|
|
|
int i, pl;
|
|
|
|
PARTITION_TYPE partition;
|
|
|
|
BLOCK_SIZE_TYPE subsize;
|
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
|
|
|
|
PARTITION_CONTEXT sl[8], sa[8];
|
|
|
|
int r = 0, d = 0;
|
|
|
|
|
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
|
|
// parse the partition type
|
|
|
|
if ((bwl == bsl) && (bhl == bsl))
|
|
|
|
partition = PARTITION_NONE;
|
|
|
|
else if ((bwl == bsl) && (bhl < bsl))
|
|
|
|
partition = PARTITION_HORZ;
|
|
|
|
else if ((bwl < bsl) && (bhl == bsl))
|
|
|
|
partition = PARTITION_VERT;
|
|
|
|
else if ((bwl < bsl) && (bhl < bsl))
|
|
|
|
partition = PARTITION_SPLIT;
|
|
|
|
else
|
|
|
|
assert(0);
|
|
|
|
|
|
|
|
subsize = get_subsize(bsize, partition);
|
|
|
|
|
|
|
|
// TODO(JBB): this restriction is here because pick_sb_modes can return
|
|
|
|
// r's that are INT_MAX meaning we can't select a mode / mv for this block.
|
|
|
|
// when the code is made to work for less than sb8x8 we need to come up with
|
|
|
|
// a solution to this problem.
|
|
|
|
assert(subsize >= BLOCK_SIZE_SB8X8);
|
|
|
|
|
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8) {
|
|
|
|
xd->left_seg_context = cm->left_seg_context + (mi_row & MI_MASK);
|
|
|
|
xd->above_seg_context = cm->above_seg_context + mi_col;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
pl = partition_plane_context(xd, bsize);
|
|
|
|
save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, bsize,
|
|
|
|
get_block_context(x, bsize));
|
|
|
|
r += x->partition_cost[pl][PARTITION_NONE];
|
|
|
|
break;
|
|
|
|
case PARTITION_HORZ:
|
|
|
|
*(get_sb_index(xd, subsize)) = 0;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, subsize,
|
|
|
|
get_block_context(x, subsize));
|
2013-06-06 15:07:09 +02:00
|
|
|
if (mi_row + (bh >> 1) <= cm->mi_rows) {
|
2013-05-31 00:13:08 +02:00
|
|
|
int rt, dt;
|
|
|
|
update_state(cpi, get_block_context(x, subsize), subsize, 0);
|
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
|
|
|
*(get_sb_index(xd, subsize)) = 1;
|
|
|
|
pick_sb_modes(cpi, mi_row + (bs >> 2), mi_col, tp, &rt, &dt, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
r += rt;
|
|
|
|
d += dt;
|
|
|
|
}
|
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
|
|
|
pl = partition_plane_context(xd, bsize);
|
|
|
|
r += x->partition_cost[pl][PARTITION_HORZ];
|
|
|
|
break;
|
|
|
|
case PARTITION_VERT:
|
|
|
|
*(get_sb_index(xd, subsize)) = 0;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
if (mi_col + (bs >> 1) <= cm->mi_cols) {
|
|
|
|
int rt, dt;
|
|
|
|
update_state(cpi, get_block_context(x, subsize), subsize, 0);
|
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
|
|
|
*(get_sb_index(xd, subsize)) = 1;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col + (bs >> 2), tp, &rt, &dt, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
r += rt;
|
|
|
|
d += dt;
|
|
|
|
}
|
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
|
|
|
pl = partition_plane_context(xd, bsize);
|
|
|
|
r += x->partition_cost[pl][PARTITION_VERT];
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int x_idx = (i & 1) * (bs >> 2);
|
|
|
|
int y_idx = (i >> 1) * (bs >> 2);
|
|
|
|
int jj = i >> 1, ii = i & 0x01;
|
|
|
|
int rt, dt;
|
|
|
|
|
|
|
|
if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
*(get_sb_index(xd, subsize)) = i;
|
|
|
|
|
|
|
|
rd_use_partition(cpi, m + jj * bss * mis + ii * bss, tp, mi_row + y_idx,
|
|
|
|
mi_col + x_idx, subsize, &rt, &dt);
|
|
|
|
r += rt;
|
|
|
|
d += dt;
|
|
|
|
}
|
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
|
|
|
pl = partition_plane_context(xd, bsize);
|
|
|
|
r += x->partition_cost[pl][PARTITION_SPLIT];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// update partition context
|
|
|
|
#if CONFIG_AB4X4
|
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8 &&
|
|
|
|
(bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
|
|
|
|
#else
|
|
|
|
if (bsize > BLOCK_SIZE_SB8X8
|
|
|
|
&& (bsize == BLOCK_SIZE_MB16X16 || partition != PARTITION_SPLIT)) {
|
|
|
|
#endif
|
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
|
|
|
update_partition_context(xd, subsize, bsize);
|
|
|
|
}
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
|
|
|
|
if (r < INT_MAX && d < INT_MAX)
|
|
|
|
encode_sb(cpi, tp, mi_row, mi_col, bsize == BLOCK_SIZE_SB64X64, bsize);
|
|
|
|
*rate = r;
|
|
|
|
*dist = d;
|
|
|
|
}
|
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
|
|
|
|
// TODO(jingning,jimbankoski,rbultje): properly skip partition types that are
|
|
|
|
// unlikely to be selected depending on previously rate-distortion optimization
|
|
|
|
// results, for encoding speed-up.
|
|
|
|
static void rd_pick_partition(VP9_COMP *cpi, TOKENEXTRA **tp,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE_TYPE bsize,
|
|
|
|
int *rate, int *dist) {
|
2013-01-07 20:41:49 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-05-08 23:24:43 +02:00
|
|
|
int bsl = b_width_log2(bsize), bs = 1 << bsl;
|
2013-05-11 02:06:37 +02:00
|
|
|
int ms = bs / 2;
|
2013-05-08 23:24:43 +02:00
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
|
|
|
|
PARTITION_CONTEXT sl[8], sa[8];
|
|
|
|
TOKENEXTRA *tp_orig = *tp;
|
2013-05-31 00:13:08 +02:00
|
|
|
int i, pl;
|
2013-05-08 23:24:43 +02:00
|
|
|
BLOCK_SIZE_TYPE subsize;
|
|
|
|
int srate = INT_MAX, sdist = INT_MAX;
|
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize < BLOCK_SIZE_SB8X8)
|
|
|
|
if (xd->ab_index != 0) {
|
|
|
|
*rate = 0;
|
|
|
|
*dist = 0;
|
|
|
|
return;
|
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
assert(mi_height_log2(bsize) == mi_width_log2(bsize));
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
2013-05-08 23:24:43 +02:00
|
|
|
|
|
|
|
// PARTITION_SPLIT
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8) {
|
2013-05-08 23:24:43 +02:00
|
|
|
int r4 = 0, d4 = 0;
|
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
|
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
int x_idx = (i & 1) * (ms >> 1);
|
|
|
|
int y_idx = (i >> 1) * (ms >> 1);
|
2013-05-16 07:28:36 +02:00
|
|
|
int r = 0, d = 0;
|
2013-05-01 01:13:20 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
|
2013-01-06 03:20:25 +01:00
|
|
|
continue;
|
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
*(get_sb_index(xd, subsize)) = i;
|
|
|
|
rd_pick_partition(cpi, tp, mi_row + y_idx, mi_col + x_idx, subsize,
|
|
|
|
&r, &d);
|
2013-05-11 02:06:37 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
r4 += r;
|
|
|
|
d4 += d;
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-05-08 23:24:43 +02:00
|
|
|
pl = partition_plane_context(xd, bsize);
|
2013-05-11 02:06:37 +02:00
|
|
|
if (r4 < INT_MAX)
|
|
|
|
r4 += x->partition_cost[pl][PARTITION_SPLIT];
|
|
|
|
assert(r4 >= 0);
|
|
|
|
assert(d4 >= 0);
|
2013-05-08 23:24:43 +02:00
|
|
|
srate = r4;
|
|
|
|
sdist = d4;
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// PARTITION_HORZ
|
|
|
|
if ((mi_col + ms <= cm->mi_cols) && (mi_row + (ms >> 1) <= cm->mi_rows) &&
|
2013-05-16 07:28:36 +02:00
|
|
|
(bsize >= BLOCK_SIZE_SB8X8)) {
|
2013-05-08 23:24:43 +02:00
|
|
|
int r2, d2;
|
|
|
|
int mb_skip = 0;
|
|
|
|
subsize = get_subsize(bsize, PARTITION_HORZ);
|
|
|
|
*(get_sb_index(xd, subsize)) = 0;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
|
|
|
|
if (mi_row + ms <= cm->mi_rows) {
|
2013-05-16 07:28:36 +02:00
|
|
|
int r = 0, d = 0;
|
2013-05-08 23:24:43 +02:00
|
|
|
update_state(cpi, get_block_context(x, subsize), subsize, 0);
|
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
|
|
|
*(get_sb_index(xd, subsize)) = 1;
|
|
|
|
pick_sb_modes(cpi, mi_row + (ms >> 1), mi_col, tp, &r, &d, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
r2 += r;
|
|
|
|
d2 += d;
|
|
|
|
} else {
|
|
|
|
if (mi_row + (ms >> 1) != cm->mi_rows)
|
|
|
|
mb_skip = 1;
|
|
|
|
}
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-05-08 23:24:43 +02:00
|
|
|
pl = partition_plane_context(xd, bsize);
|
2013-05-16 07:28:36 +02:00
|
|
|
if (r2 < INT_MAX)
|
|
|
|
r2 += x->partition_cost[pl][PARTITION_HORZ];
|
2013-05-08 23:24:43 +02:00
|
|
|
if ((RDCOST(x->rdmult, x->rddiv, r2, d2) <
|
|
|
|
RDCOST(x->rdmult, x->rddiv, srate, sdist)) && !mb_skip) {
|
|
|
|
srate = r2;
|
|
|
|
sdist = d2;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
2013-04-17 18:25:06 +02:00
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// PARTITION_VERT
|
|
|
|
if ((mi_row + ms <= cm->mi_rows) && (mi_col + (ms >> 1) <= cm->mi_cols) &&
|
2013-05-16 07:28:36 +02:00
|
|
|
(bsize >= BLOCK_SIZE_SB8X8)) {
|
2013-05-08 23:24:43 +02:00
|
|
|
int r2, d2;
|
|
|
|
int mb_skip = 0;
|
|
|
|
subsize = get_subsize(bsize, PARTITION_VERT);
|
|
|
|
*(get_sb_index(xd, subsize)) = 0;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col, tp, &r2, &d2, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
if (mi_col + ms <= cm->mi_cols) {
|
2013-05-16 07:28:36 +02:00
|
|
|
int r = 0, d = 0;
|
2013-05-08 23:24:43 +02:00
|
|
|
update_state(cpi, get_block_context(x, subsize), subsize, 0);
|
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
|
|
|
*(get_sb_index(xd, subsize)) = 1;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col + (ms >> 1), tp, &r, &d, subsize,
|
|
|
|
get_block_context(x, subsize));
|
|
|
|
r2 += r;
|
|
|
|
d2 += d;
|
|
|
|
} else {
|
|
|
|
if (mi_col + (ms >> 1) != cm->mi_cols)
|
|
|
|
mb_skip = 1;
|
|
|
|
}
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-05-08 23:24:43 +02:00
|
|
|
pl = partition_plane_context(xd, bsize);
|
2013-05-16 07:28:36 +02:00
|
|
|
if (r2 < INT_MAX)
|
|
|
|
r2 += x->partition_cost[pl][PARTITION_VERT];
|
2013-05-08 23:24:43 +02:00
|
|
|
if ((RDCOST(x->rdmult, x->rddiv, r2, d2) <
|
|
|
|
RDCOST(x->rdmult, x->rddiv, srate, sdist)) && !mb_skip) {
|
|
|
|
srate = r2;
|
|
|
|
sdist = d2;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// PARTITION_NONE
|
|
|
|
if (mi_row + ms <= cm->mi_rows && mi_col + ms <= cm->mi_cols) {
|
|
|
|
int r, d;
|
|
|
|
pick_sb_modes(cpi, mi_row, mi_col, tp, &r, &d, bsize,
|
|
|
|
get_block_context(x, bsize));
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8) {
|
2013-05-12 00:19:56 +02:00
|
|
|
set_partition_seg_context(cm, xd, mi_row, mi_col);
|
2013-05-08 23:24:43 +02:00
|
|
|
pl = partition_plane_context(xd, bsize);
|
|
|
|
r += x->partition_cost[pl][PARTITION_NONE];
|
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
if (RDCOST(x->rdmult, x->rddiv, r, d) <
|
|
|
|
RDCOST(x->rdmult, x->rddiv, srate, sdist)) {
|
|
|
|
srate = r;
|
|
|
|
sdist = d;
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize >= BLOCK_SIZE_SB8X8)
|
2013-05-08 23:24:43 +02:00
|
|
|
*(get_sb_partitioning(x, bsize)) = bsize;
|
2013-04-17 18:25:06 +02:00
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
*rate = srate;
|
|
|
|
*dist = sdist;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
if (srate < INT_MAX && sdist < INT_MAX)
|
|
|
|
encode_sb(cpi, tp, mi_row, mi_col, bsize == BLOCK_SIZE_SB64X64, bsize);
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
if (bsize == BLOCK_SIZE_SB64X64) {
|
2013-05-08 23:24:43 +02:00
|
|
|
assert(tp_orig < *tp);
|
2013-05-11 02:06:37 +02:00
|
|
|
assert(srate < INT_MAX);
|
|
|
|
assert(sdist < INT_MAX);
|
|
|
|
} else {
|
2013-05-08 23:24:43 +02:00
|
|
|
assert(tp_orig == *tp);
|
2013-05-11 02:06:37 +02:00
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
static void encode_sb_row(VP9_COMP *cpi, int mi_row,
|
|
|
|
TOKENEXTRA **tp, int *totalrate) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
int mi_col;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// Initialize the left context for the new SB row
|
|
|
|
vpx_memset(&cm->left_context, 0, sizeof(cm->left_context));
|
|
|
|
vpx_memset(cm->left_seg_context, 0, sizeof(cm->left_seg_context));
|
|
|
|
|
|
|
|
// Code each SB in the row
|
|
|
|
for (mi_col = cm->cur_tile_mi_col_start;
|
|
|
|
mi_col < cm->cur_tile_mi_col_end; mi_col += 8) {
|
|
|
|
int dummy_rate, dummy_dist;
|
2013-06-06 15:07:09 +02:00
|
|
|
if (cpi->speed < 5) {
|
2013-05-31 00:13:08 +02:00
|
|
|
rd_pick_partition(cpi, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
|
|
|
|
&dummy_rate, &dummy_dist);
|
|
|
|
} else {
|
|
|
|
const int idx_str = cm->mode_info_stride * mi_row + mi_col;
|
|
|
|
MODE_INFO *m = cm->mi + idx_str;
|
2013-06-06 15:07:09 +02:00
|
|
|
// set_partitioning(cpi, m, BLOCK_SIZE_SB64X64);
|
2013-05-31 00:13:08 +02:00
|
|
|
choose_partitioning(cpi, cm->mi, mi_row, mi_col);
|
|
|
|
rd_use_partition(cpi, m, tp, mi_row, mi_col, BLOCK_SIZE_SB64X64,
|
|
|
|
&dummy_rate, &dummy_dist);
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-09-30 17:45:16 +02:00
|
|
|
}
|
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static void init_encode_frame_mb_context(VP9_COMP *cpi) {
|
2012-10-17 23:51:27 +02:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2012-10-17 23:51:27 +02:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
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;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->mode_info_stride = cm->mode_info_stride;
|
|
|
|
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)
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_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.
|
2013-04-24 01:22:47 +02:00
|
|
|
vp9_setup_src_planes(x, cpi->Source, 0, 0);
|
2013-04-20 04:16:14 +02:00
|
|
|
|
|
|
|
// TODO(jkoleszar): are these initializations required?
|
|
|
|
setup_pre_planes(xd, &cm->yv12_fb[cm->ref_frame_map[cpi->lst_fb_idx]], NULL,
|
|
|
|
0, 0, NULL, NULL);
|
2013-04-20 00:52:17 +02:00
|
|
|
setup_dst_planes(xd, &cm->yv12_fb[cm->new_fb_idx], 0, 0);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-10-30 20:58:42 +01:00
|
|
|
vp9_build_block_offsets(x);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2013-05-07 00:52:06 +02:00
|
|
|
vp9_setup_block_dptrs(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);
|
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
|
|
|
|
2013-05-30 18:58:53 +02:00
|
|
|
vp9_zero(cpi->y_mode_count)
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_zero(cpi->y_uv_mode_count)
|
2013-06-06 20:14:04 +02:00
|
|
|
vp9_zero(cm->fc.inter_mode_counts)
|
2013-04-16 09:18:02 +02:00
|
|
|
vp9_zero(cpi->partition_count);
|
2013-06-06 22:44:34 +02:00
|
|
|
vp9_zero(cpi->intra_inter_count);
|
|
|
|
vp9_zero(cpi->comp_inter_count);
|
|
|
|
vp9_zero(cpi->single_ref_count);
|
|
|
|
vp9_zero(cpi->comp_ref_count);
|
2013-06-06 20:14:04 +02:00
|
|
|
vp9_zero(cm->fc.tx_count_32x32p);
|
|
|
|
vp9_zero(cm->fc.tx_count_16x16p);
|
|
|
|
vp9_zero(cm->fc.tx_count_8x8p);
|
2013-04-16 09:18:02 +02:00
|
|
|
|
2013-04-29 19:37:25 +02:00
|
|
|
// Note: this memset assumes above_context[0], [1] and [2]
|
|
|
|
// are allocated as part of the same buffer.
|
2013-05-08 00:36:30 +02:00
|
|
|
vpx_memset(cm->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
|
|
|
|
MAX_MB_PLANE * mi_cols_aligned_to_sb(cm));
|
2013-04-23 19:12:18 +02:00
|
|
|
vpx_memset(cm->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
|
2013-05-08 00:36:30 +02:00
|
|
|
mi_cols_aligned_to_sb(cm));
|
2011-06-08 17:00:59 +02:00
|
|
|
}
|
2013-02-20 16:27:35 +01:00
|
|
|
|
2013-02-13 23:22:15 +01:00
|
|
|
static void switch_lossless_mode(VP9_COMP *cpi, int lossless) {
|
|
|
|
if (lossless) {
|
2013-03-12 19:24:04 +01:00
|
|
|
cpi->mb.fwd_txm8x4 = vp9_short_walsh8x4;
|
|
|
|
cpi->mb.fwd_txm4x4 = vp9_short_walsh4x4;
|
2013-05-20 19:03:17 +02:00
|
|
|
cpi->mb.e_mbd.inv_txm4x4_1_add = vp9_short_iwalsh4x4_1_add;
|
|
|
|
cpi->mb.e_mbd.inv_txm4x4_add = vp9_short_iwalsh4x4_add;
|
2013-02-13 23:22:15 +01:00
|
|
|
cpi->mb.optimize = 0;
|
|
|
|
cpi->common.filter_level = 0;
|
2013-04-16 00:24:39 +02:00
|
|
|
cpi->zbin_mode_boost_enabled = 0;
|
2013-02-13 23:22:15 +01:00
|
|
|
cpi->common.txfm_mode = ONLY_4X4;
|
|
|
|
} else {
|
|
|
|
cpi->mb.fwd_txm8x4 = vp9_short_fdct8x4;
|
|
|
|
cpi->mb.fwd_txm4x4 = vp9_short_fdct4x4;
|
2013-05-20 19:03:17 +02:00
|
|
|
cpi->mb.e_mbd.inv_txm4x4_1_add = vp9_short_idct4x4_1_add;
|
|
|
|
cpi->mb.e_mbd.inv_txm4x4_add = vp9_short_idct4x4_add;
|
2013-02-13 23:22:15 +01:00
|
|
|
}
|
|
|
|
}
|
2013-02-20 16:27:35 +01:00
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static void encode_frame_internal(VP9_COMP *cpi) {
|
2013-04-26 20:57:17 +02:00
|
|
|
int mi_row;
|
2012-10-17 23:51:27 +02:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2012-10-17 23:51:27 +02:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2012-07-14 00:21:29 +02:00
|
|
|
int totalrate;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-15 18:31:27 +02:00
|
|
|
// fprintf(stderr, "encode_frame_internal frame %d (%d) type %d\n",
|
|
|
|
// cpi->common.current_video_frame, cpi->common.show_frame,
|
|
|
|
// cm->frame_type);
|
2012-09-10 07:42:35 +02:00
|
|
|
|
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;
|
|
|
|
|
|
|
|
// 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->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
|
|
|
|
2013-06-05 00:25:16 +02:00
|
|
|
vp9_zero(cm->fc.switchable_interp_count);
|
2012-12-20 23:56:19 +01:00
|
|
|
vp9_zero(cpi->best_switchable_interp_count);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
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-10-31 22:40:53 +01:00
|
|
|
vp9_zero(cpi->NMVcount);
|
2013-05-31 18:18:59 +02:00
|
|
|
vp9_zero(cpi->coef_counts);
|
2013-03-27 00:46:09 +01:00
|
|
|
vp9_zero(cm->fc.eob_branch_counts);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-16 03:20:51 +02:00
|
|
|
cpi->mb.e_mbd.lossless = cm->base_qindex == 0 &&
|
|
|
|
cm->y_dc_delta_q == 0 &&
|
|
|
|
cm->uv_dc_delta_q == 0 &&
|
|
|
|
cm->uv_ac_delta_q == 0;
|
2013-02-13 23:22:15 +01:00
|
|
|
switch_lossless_mode(cpi, cpi->mb.e_mbd.lossless);
|
2013-02-20 16:27:35 +01:00
|
|
|
|
2012-10-30 22:25:33 +01:00
|
|
|
vp9_frame_init_quantizer(cpi);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-17 00:05:52 +02:00
|
|
|
vp9_initialize_rd_consts(cpi, cm->base_qindex + cm->y_dc_delta_q);
|
2012-10-30 22:25:33 +01:00
|
|
|
vp9_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-10-09 18:18:21 +02:00
|
|
|
vpx_memset(cpi->rd_tx_select_diff, 0, sizeof(cpi->rd_tx_select_diff));
|
2013-05-24 18:23:15 +02:00
|
|
|
vpx_memset(cpi->rd_tx_select_threshes, 0, sizeof(cpi->rd_tx_select_threshes));
|
2013-05-24 20:11:06 +02:00
|
|
|
|
2013-05-29 22:42:23 +02:00
|
|
|
set_prev_mi(cm);
|
|
|
|
|
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
|
|
|
{
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
// Take tiles into account and give start/end MB
|
2013-02-20 19:16:24 +01:00
|
|
|
int tile_col, tile_row;
|
2013-02-08 20:33:11 +01:00
|
|
|
TOKENEXTRA *tp = cpi->tok;
|
2013-02-28 02:09:12 +01:00
|
|
|
|
2013-02-20 19:16:24 +01:00
|
|
|
for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
|
|
|
|
vp9_get_tile_row_offsets(cm, tile_row);
|
|
|
|
|
|
|
|
for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
|
|
|
|
TOKENEXTRA *tp_old = tp;
|
|
|
|
|
|
|
|
// For each row of SBs in the frame
|
|
|
|
vp9_get_tile_col_offsets(cm, tile_col);
|
2013-04-26 20:57:17 +02:00
|
|
|
for (mi_row = cm->cur_tile_mi_row_start;
|
|
|
|
mi_row < cm->cur_tile_mi_row_end;
|
2013-05-08 23:24:43 +02:00
|
|
|
mi_row += 8)
|
2013-04-26 20:57:17 +02:00
|
|
|
encode_sb_row(cpi, mi_row, &tp, &totalrate);
|
2013-02-20 19:16:24 +01:00
|
|
|
cpi->tok_count[tile_col] = (unsigned int)(tp - tp_old);
|
2013-03-28 18:42:23 +01:00
|
|
|
assert(tp - cpi->tok <=
|
|
|
|
get_token_alloc(cm->mb_rows, cm->mb_cols));
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01: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
|
|
|
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-10-31 01:53:32 +01:00
|
|
|
static int check_dual_ref_flags(VP9_COMP *cpi) {
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
|
|
|
int ref_flags = cpi->ref_frame_flags;
|
|
|
|
|
2012-10-30 06:15:27 +01:00
|
|
|
if (vp9_segfeature_active(xd, 1, SEG_LVL_REF_FRAME)) {
|
2012-10-31 22:40:53 +01:00
|
|
|
if ((ref_flags & (VP9_LAST_FLAG | VP9_GOLD_FLAG)) == (VP9_LAST_FLAG | VP9_GOLD_FLAG) &&
|
2012-10-30 06:15:27 +01:00
|
|
|
vp9_check_segref(xd, 1, LAST_FRAME))
|
2012-07-14 00:21:29 +02:00
|
|
|
return 1;
|
2012-10-31 22:40:53 +01:00
|
|
|
if ((ref_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) == (VP9_GOLD_FLAG | VP9_ALT_FLAG) &&
|
2012-10-30 06:15:27 +01:00
|
|
|
vp9_check_segref(xd, 1, GOLDEN_FRAME))
|
2012-07-14 00:21:29 +02:00
|
|
|
return 1;
|
2012-10-31 22:40:53 +01:00
|
|
|
if ((ref_flags & (VP9_ALT_FLAG | VP9_LAST_FLAG)) == (VP9_ALT_FLAG | VP9_LAST_FLAG) &&
|
2012-10-30 06:15:27 +01:00
|
|
|
vp9_check_segref(xd, 1, ALTREF_FRAME))
|
2012-07-14 00:21:29 +02:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
} else {
|
2012-10-31 22:40:53 +01:00
|
|
|
return (!!(ref_flags & VP9_GOLD_FLAG) +
|
|
|
|
!!(ref_flags & VP9_LAST_FLAG) +
|
|
|
|
!!(ref_flags & VP9_ALT_FLAG)) >= 2;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-03-22 18:03:14 +01:00
|
|
|
}
|
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
static int get_skip_flag(MODE_INFO *mi, int mis, int ymbs, int xmbs) {
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
for (y = 0; y < ymbs; y++) {
|
|
|
|
for (x = 0; x < xmbs; x++) {
|
|
|
|
if (!mi[y * mis + x].mbmi.mb_skip_coeff)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_txfm_flag(MODE_INFO *mi, int mis, int ymbs, int xmbs,
|
|
|
|
TX_SIZE txfm_size) {
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
for (y = 0; y < ymbs; y++) {
|
2013-02-28 22:18:02 +01:00
|
|
|
for (x = 0; x < xmbs; x++)
|
2013-01-06 03:20:25 +01:00
|
|
|
mi[y * mis + x].mbmi.txfm_size = txfm_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-28 00:26:39 +02:00
|
|
|
static void reset_skip_txfm_size_b(VP9_COMP *cpi, MODE_INFO *mi,
|
|
|
|
int mis, TX_SIZE txfm_max,
|
|
|
|
int bw, int bh, int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2013-01-06 03:20:25 +01:00
|
|
|
MB_MODE_INFO *const mbmi = &mi->mbmi;
|
|
|
|
|
2013-04-28 00:26:39 +02:00
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
if (mbmi->txfm_size > txfm_max) {
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
const int segment_id = mbmi->segment_id;
|
2013-04-28 00:26:39 +02:00
|
|
|
const int ymbs = MIN(bh, cm->mi_rows - mi_row);
|
|
|
|
const int xmbs = MIN(bw, cm->mi_cols - mi_col);
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
xd->mode_info_context = mi;
|
2013-04-09 19:54:19 +02:00
|
|
|
assert(vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP) ||
|
|
|
|
get_skip_flag(mi, mis, ymbs, xmbs));
|
2013-01-06 03:20:25 +01:00
|
|
|
set_txfm_flag(mi, mis, ymbs, xmbs, txfm_max);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-28 00:26:39 +02:00
|
|
|
static void reset_skip_txfm_size_sb(VP9_COMP *cpi, MODE_INFO *mi,
|
|
|
|
TX_SIZE txfm_max,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
const int mis = cm->mode_info_stride;
|
|
|
|
int bwl, bhl;
|
|
|
|
const int bsl = mi_width_log2(bsize), bs = 1 << (bsl - 1);
|
|
|
|
|
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bwl = mi_width_log2(mi->mbmi.sb_type);
|
|
|
|
bhl = mi_height_log2(mi->mbmi.sb_type);
|
|
|
|
|
|
|
|
if (bwl == bsl && bhl == bsl) {
|
|
|
|
reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, 1 << bsl, 1 << bsl,
|
|
|
|
mi_row, mi_col, bsize);
|
|
|
|
} else if (bwl == bsl && bhl < bsl) {
|
|
|
|
reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, 1 << bsl, bs,
|
|
|
|
mi_row, mi_col, bsize);
|
|
|
|
reset_skip_txfm_size_b(cpi, mi + bs * mis, mis, txfm_max, 1 << bsl, bs,
|
|
|
|
mi_row + bs, mi_col, bsize);
|
|
|
|
} else if (bwl < bsl && bhl == bsl) {
|
|
|
|
reset_skip_txfm_size_b(cpi, mi, mis, txfm_max, bs, 1 << bsl,
|
|
|
|
mi_row, mi_col, bsize);
|
|
|
|
reset_skip_txfm_size_b(cpi, mi + bs, mis, txfm_max, bs, 1 << bsl,
|
|
|
|
mi_row, mi_col + bs, bsize);
|
|
|
|
} else {
|
|
|
|
BLOCK_SIZE_TYPE subsize;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
assert(bwl < bsl && bhl < bsl);
|
|
|
|
if (bsize == BLOCK_SIZE_SB64X64) {
|
|
|
|
subsize = BLOCK_SIZE_SB32X32;
|
2013-05-01 01:13:20 +02:00
|
|
|
} else if (bsize == BLOCK_SIZE_SB32X32) {
|
|
|
|
subsize = BLOCK_SIZE_MB16X16;
|
|
|
|
} else {
|
|
|
|
assert(bsize == BLOCK_SIZE_MB16X16);
|
|
|
|
subsize = BLOCK_SIZE_SB8X8;
|
2013-04-28 00:26:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (n = 0; n < 4; n++) {
|
|
|
|
const int y_idx = n >> 1, x_idx = n & 0x01;
|
|
|
|
|
|
|
|
reset_skip_txfm_size_sb(cpi, mi + y_idx * bs * mis + x_idx * bs,
|
|
|
|
txfm_max, mi_row + y_idx * bs,
|
|
|
|
mi_col + x_idx * bs, subsize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
static void reset_skip_txfm_size(VP9_COMP *cpi, TX_SIZE txfm_max) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2013-04-26 20:57:17 +02:00
|
|
|
int mi_row, mi_col;
|
2013-01-06 03:20:25 +01:00
|
|
|
const int mis = cm->mode_info_stride;
|
|
|
|
MODE_INFO *mi, *mi_ptr = cm->mi;
|
2012-10-12 03:19:20 +02:00
|
|
|
|
2013-04-26 20:57:17 +02:00
|
|
|
for (mi_row = 0; mi_row < cm->mi_rows;
|
2013-05-05 07:09:43 +02:00
|
|
|
mi_row += 8, mi_ptr += 8 * mis) {
|
2012-10-12 03:19:20 +02:00
|
|
|
mi = mi_ptr;
|
2013-04-26 20:57:17 +02:00
|
|
|
for (mi_col = 0; mi_col < cm->mi_cols;
|
2013-05-05 07:09:43 +02:00
|
|
|
mi_col += 8, mi += 8) {
|
2013-04-28 00:26:39 +02:00
|
|
|
reset_skip_txfm_size_sb(cpi, mi, txfm_max,
|
|
|
|
mi_row, mi_col, BLOCK_SIZE_SB64X64);
|
2012-10-12 03:19:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
void vp9_encode_frame(VP9_COMP *cpi) {
|
2013-06-06 22:44:34 +02:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
|
2013-06-07 13:29:15 +02:00
|
|
|
// In the longer term the encoder should be generalized to match the
|
|
|
|
// decoder such that we allow compound where one of the 3 buffers has a
|
|
|
|
// differnt sign bias and that buffer is then the fixed ref. However, this
|
|
|
|
// requires further work in the rd loop. For now the only supported encoder
|
|
|
|
// side behaviour is where the ALT ref buffer has oppositie sign bias to
|
|
|
|
// the other two.
|
|
|
|
if ((cm->ref_frame_sign_bias[ALTREF_FRAME] ==
|
|
|
|
cm->ref_frame_sign_bias[GOLDEN_FRAME]) ||
|
|
|
|
(cm->ref_frame_sign_bias[ALTREF_FRAME] ==
|
|
|
|
cm->ref_frame_sign_bias[LAST_FRAME])) {
|
2013-06-06 22:44:34 +02:00
|
|
|
cm->allow_comp_inter_inter = 0;
|
|
|
|
} else {
|
|
|
|
cm->allow_comp_inter_inter = 1;
|
|
|
|
cm->comp_fixed_ref = ALTREF_FRAME;
|
|
|
|
cm->comp_var_ref[0] = LAST_FRAME;
|
|
|
|
cm->comp_var_ref[1] = GOLDEN_FRAME;
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->sf.RD) {
|
2012-08-10 03:25:29 +02:00
|
|
|
int i, frame_type, pred_type;
|
2012-10-09 18:18:21 +02:00
|
|
|
TXFM_MODE txfm_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
|
2012-10-09 18:18:21 +02:00
|
|
|
* that for subsequent frames.
|
|
|
|
* It does the same analysis for transform size selection also.
|
2012-07-14 00:21:29 +02:00
|
|
|
*/
|
|
|
|
if (cpi->common.frame_type == KEY_FRAME)
|
|
|
|
frame_type = 0;
|
2013-01-15 22:49:44 +01:00
|
|
|
else if (cpi->is_src_frame_alt_ref && cpi->refresh_golden_frame)
|
2012-07-14 00:21:29 +02:00
|
|
|
frame_type = 3;
|
2013-01-15 22:49:44 +01:00
|
|
|
else if (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
|
|
|
|
2012-10-09 18:18:21 +02:00
|
|
|
/* prediction (compound, single or hybrid) mode selection */
|
2013-06-06 22:44:34 +02:00
|
|
|
if (frame_type == 3 || !cm->allow_comp_inter_inter)
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
|
|
|
|
2012-10-09 18:18:21 +02:00
|
|
|
/* transform size (4x4, 8x8, 16x16 or select-per-mb) selection */
|
2013-02-20 16:27:35 +01:00
|
|
|
|
2013-02-12 00:58:22 +01:00
|
|
|
cpi->mb.e_mbd.lossless = 0;
|
2012-10-09 18:18:21 +02:00
|
|
|
if (cpi->oxcf.lossless) {
|
|
|
|
txfm_type = ONLY_4X4;
|
2013-02-12 00:58:22 +01:00
|
|
|
cpi->mb.e_mbd.lossless = 1;
|
2012-10-09 18:18:21 +02:00
|
|
|
} else
|
|
|
|
#if 0
|
2013-03-07 19:45:25 +01:00
|
|
|
/* FIXME (rbultje): this code is disabled until we support cost updates
|
|
|
|
* while a frame is being encoded; the problem is that each time we
|
|
|
|
* "revert" to 4x4 only (or even 8x8 only), the coefficient probabilities
|
|
|
|
* for 16x16 (and 8x8) start lagging behind, thus leading to them lagging
|
|
|
|
* further behind and not being chosen for subsequent frames either. This
|
|
|
|
* is essentially a local minimum problem that we can probably fix by
|
|
|
|
* estimating real costs more closely within a frame, perhaps by re-
|
|
|
|
* calculating costs on-the-fly as frame encoding progresses. */
|
2012-10-09 18:18:21 +02:00
|
|
|
if (cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] >
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][ONLY_4X4] &&
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] >
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][ALLOW_16X16] &&
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] >
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][ALLOW_8X8]) {
|
|
|
|
txfm_type = TX_MODE_SELECT;
|
|
|
|
} else if (cpi->rd_tx_select_threshes[frame_type][ONLY_4X4] >
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][ALLOW_8X8]
|
|
|
|
&& cpi->rd_tx_select_threshes[frame_type][ONLY_4X4] >
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][ALLOW_16X16]
|
|
|
|
) {
|
|
|
|
txfm_type = ONLY_4X4;
|
|
|
|
} else if (cpi->rd_tx_select_threshes[frame_type][ALLOW_16X16] >=
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][ALLOW_8X8]) {
|
|
|
|
txfm_type = ALLOW_16X16;
|
|
|
|
} else
|
|
|
|
txfm_type = ALLOW_8X8;
|
|
|
|
#else
|
2013-05-24 20:11:06 +02:00
|
|
|
txfm_type = cpi->rd_tx_select_threshes[frame_type][ALLOW_32X32] >
|
2013-01-10 17:23:59 +01:00
|
|
|
cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] ?
|
|
|
|
ALLOW_32X32 : TX_MODE_SELECT;
|
2012-10-09 18:18:21 +02:00
|
|
|
#endif
|
|
|
|
cpi->common.txfm_mode = txfm_type;
|
2012-07-14 00:21:29 +02:00
|
|
|
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) {
|
2012-11-05 23:22:59 +01:00
|
|
|
const int diff = (int)(cpi->rd_comp_pred_diff[i] / cpi->common.MBs);
|
2012-08-10 03:25:29 +02:00
|
|
|
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
|
|
|
|
2012-10-09 18:18:21 +02:00
|
|
|
for (i = 0; i < NB_TXFM_MODES; ++i) {
|
|
|
|
int64_t pd = cpi->rd_tx_select_diff[i];
|
|
|
|
int diff;
|
|
|
|
if (i == TX_MODE_SELECT)
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
pd -= RDCOST(cpi->mb.rdmult, cpi->mb.rddiv,
|
|
|
|
2048 * (TX_SIZE_MAX_SB - 1), 0);
|
2012-11-05 23:22:59 +01:00
|
|
|
diff = (int)(pd / cpi->common.MBs);
|
2012-10-09 18:18:21 +02:00
|
|
|
cpi->rd_tx_select_threshes[frame_type][i] += diff;
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][i] /= 2;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
for (i = 0; i < COMP_INTER_CONTEXTS; i++) {
|
|
|
|
single_count_zero += cpi->comp_inter_count[i][0];
|
|
|
|
comp_count_zero += cpi->comp_inter_count[i][1];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (comp_count_zero == 0) {
|
|
|
|
cpi->common.comp_pred_mode = SINGLE_PREDICTION_ONLY;
|
2013-06-06 22:44:34 +02:00
|
|
|
vp9_zero(cpi->comp_inter_count);
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (single_count_zero == 0) {
|
|
|
|
cpi->common.comp_pred_mode = COMP_PREDICTION_ONLY;
|
2013-06-06 22:44:34 +02:00
|
|
|
vp9_zero(cpi->comp_inter_count);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
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-10-09 18:18:21 +02:00
|
|
|
|
|
|
|
if (cpi->common.txfm_mode == TX_MODE_SELECT) {
|
2013-06-06 20:14:04 +02:00
|
|
|
const int count4x4 = cm->fc.tx_count_16x16p[TX_4X4] +
|
|
|
|
cm->fc.tx_count_32x32p[TX_4X4] +
|
|
|
|
cm->fc.tx_count_8x8p[TX_4X4];
|
|
|
|
const int count8x8_lp = cm->fc.tx_count_32x32p[TX_8X8] +
|
|
|
|
cm->fc.tx_count_16x16p[TX_8X8];
|
|
|
|
const int count8x8_8x8p = cm->fc.tx_count_8x8p[TX_8X8];
|
|
|
|
const int count16x16_16x16p = cm->fc.tx_count_16x16p[TX_16X16];
|
|
|
|
const int count16x16_lp = cm->fc.tx_count_32x32p[TX_16X16];
|
|
|
|
const int count32x32 = cm->fc.tx_count_32x32p[TX_32X32];
|
2012-10-09 18:18:21 +02:00
|
|
|
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
if (count4x4 == 0 && count16x16_lp == 0 && count16x16_16x16p == 0 &&
|
|
|
|
count32x32 == 0) {
|
2012-10-09 18:18:21 +02:00
|
|
|
cpi->common.txfm_mode = ALLOW_8X8;
|
2012-10-12 03:19:20 +02:00
|
|
|
reset_skip_txfm_size(cpi, TX_8X8);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
} else if (count8x8_8x8p == 0 && count16x16_16x16p == 0 &&
|
|
|
|
count8x8_lp == 0 && count16x16_lp == 0 && count32x32 == 0) {
|
2012-10-09 18:18:21 +02:00
|
|
|
cpi->common.txfm_mode = ONLY_4X4;
|
2012-10-12 03:19:20 +02:00
|
|
|
reset_skip_txfm_size(cpi, TX_4X4);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
} else if (count8x8_lp == 0 && count16x16_lp == 0 && count4x4 == 0) {
|
|
|
|
cpi->common.txfm_mode = ALLOW_32X32;
|
|
|
|
} else if (count32x32 == 0 && count8x8_lp == 0 && count4x4 == 0) {
|
2012-10-09 18:18:21 +02:00
|
|
|
cpi->common.txfm_mode = ALLOW_16X16;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
reset_skip_txfm_size(cpi, TX_16X16);
|
2012-10-09 18:18:21 +02:00
|
|
|
}
|
|
|
|
}
|
2012-12-20 23:56:19 +01:00
|
|
|
|
|
|
|
// Update interpolation filter strategy for next frame.
|
|
|
|
if ((cpi->common.frame_type != KEY_FRAME) && (cpi->sf.search_best_filter))
|
2013-02-28 22:18:02 +01:00
|
|
|
vp9_select_interp_filter_type(cpi);
|
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-10-30 20:58:42 +01:00
|
|
|
void vp9_build_block_offsets(MACROBLOCK *x) {
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static void sum_intra_stats(VP9_COMP *cpi, MACROBLOCK *x) {
|
2012-10-17 23:51:27 +02:00
|
|
|
const MACROBLOCKD *xd = &x->e_mbd;
|
2012-07-14 00:21:29 +02:00
|
|
|
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
|
|
|
|
2013-05-30 18:58:53 +02:00
|
|
|
++cpi->y_uv_mode_count[m][uvm];
|
2013-05-11 02:06:37 +02:00
|
|
|
if (xd->mode_info_context->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
|
2013-06-03 19:39:40 +02:00
|
|
|
const BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
|
|
|
|
const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
|
|
|
|
const int bsl = MIN(bwl, bhl);
|
|
|
|
++cpi->y_mode_count[MIN(bsl, 3)][m];
|
2013-01-08 19:29:22 +01:00
|
|
|
} else {
|
2013-05-20 21:08:22 +02:00
|
|
|
int idx, idy;
|
|
|
|
int bw = 1 << b_width_log2(xd->mode_info_context->mbmi.sb_type);
|
|
|
|
int bh = 1 << b_height_log2(xd->mode_info_context->mbmi.sb_type);
|
|
|
|
for (idy = 0; idy < 2; idy += bh) {
|
|
|
|
for (idx = 0; idx < 2; idx += bw) {
|
|
|
|
int m = xd->mode_info_context->bmi[idy * 2 + idx].as_mode.first;
|
2013-06-03 19:39:40 +02:00
|
|
|
++cpi->y_mode_count[0][m];
|
2013-05-20 21:08:22 +02:00
|
|
|
}
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
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-10-31 01:53:32 +01:00
|
|
|
static void adjust_act_zbin(VP9_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
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t,
|
2013-04-26 20:57:17 +02:00
|
|
|
int output_enabled, int mi_row, int mi_col,
|
2013-04-10 06:28:27 +02:00
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-01-06 03:20:25 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
int n;
|
2013-05-21 00:59:39 +02:00
|
|
|
MODE_INFO *mi = xd->mode_info_context;
|
|
|
|
MB_MODE_INFO *mbmi = &mi->mbmi;
|
|
|
|
unsigned int segment_id = mbmi->segment_id;
|
2013-01-06 03:20:25 +01:00
|
|
|
const int mis = cm->mode_info_stride;
|
2013-04-26 20:57:17 +02:00
|
|
|
const int bwl = mi_width_log2(bsize);
|
|
|
|
const int bw = 1 << bwl, bh = 1 << mi_height_log2(bsize);
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
if (cm->frame_type == KEY_FRAME) {
|
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
vp9_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
} else {
|
2013-05-21 00:59:39 +02:00
|
|
|
vp9_setup_interp_filters(xd, mbmi->interp_filter, cm);
|
2013-01-06 03:20:25 +01: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) {
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[0] != INTRA_FRAME) {
|
2013-05-21 00:59:39 +02:00
|
|
|
if (mbmi->mode == ZEROMV) {
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[0] != LAST_FRAME)
|
2013-01-06 03:20:25 +01:00
|
|
|
cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
|
|
|
|
else
|
|
|
|
cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
|
2013-05-30 21:49:38 +02:00
|
|
|
} else if (mbmi->sb_type < BLOCK_SIZE_SB8X8) {
|
2013-03-21 19:37:48 +01:00
|
|
|
cpi->zbin_mode_boost = SPLIT_MV_ZBIN_BOOST;
|
2013-01-06 03:20:25 +01:00
|
|
|
} else {
|
|
|
|
cpi->zbin_mode_boost = MV_ZBIN_BOOST;
|
|
|
|
}
|
2013-03-21 19:37:48 +01:00
|
|
|
} else {
|
|
|
|
cpi->zbin_mode_boost = INTRA_ZBIN_BOOST;
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vp9_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[0] == INTRA_FRAME) {
|
2013-05-22 06:28:42 +02:00
|
|
|
vp9_encode_intra_block_y(cm, x, (bsize < BLOCK_SIZE_SB8X8) ?
|
|
|
|
BLOCK_SIZE_SB8X8 : bsize);
|
|
|
|
vp9_encode_intra_block_uv(cm, x, (bsize < BLOCK_SIZE_SB8X8) ?
|
|
|
|
BLOCK_SIZE_SB8X8 : bsize);
|
2013-01-06 03:20:25 +01:00
|
|
|
if (output_enabled)
|
|
|
|
sum_intra_stats(cpi, x);
|
2012-11-08 20:03:00 +01:00
|
|
|
} else {
|
2013-06-06 22:44:34 +02:00
|
|
|
int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame[0])];
|
2013-05-21 00:59:39 +02:00
|
|
|
YV12_BUFFER_CONFIG *ref_fb = &cm->yv12_fb[idx];
|
|
|
|
YV12_BUFFER_CONFIG *second_ref_fb = NULL;
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mbmi->ref_frame[1] > 0) {
|
|
|
|
idx = cm->ref_frame_map[get_ref_frame_idx(cpi, mbmi->ref_frame[1])];
|
2013-05-21 00:59:39 +02:00
|
|
|
second_ref_fb = &cm->yv12_fb[idx];
|
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
assert(cm->frame_type != KEY_FRAME);
|
|
|
|
|
2013-05-21 00:59:39 +02:00
|
|
|
setup_pre_planes(xd, ref_fb, second_ref_fb,
|
|
|
|
mi_row, mi_col, xd->scale_factor, xd->scale_factor_uv);
|
2013-04-20 04:16:14 +02:00
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
vp9_build_inter_predictors_sb(xd, mi_row, mi_col,
|
2013-05-21 00:59:39 +02:00
|
|
|
bsize < BLOCK_SIZE_SB8X8 ? BLOCK_SIZE_SB8X8
|
|
|
|
: bsize);
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) {
|
2013-05-17 21:50:40 +02:00
|
|
|
vp9_tokenize_sb(cpi, xd, t, !output_enabled,
|
|
|
|
(bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
|
2013-05-05 07:09:43 +02:00
|
|
|
} else if (!x->skip) {
|
2013-05-11 02:06:37 +02:00
|
|
|
vp9_encode_sb(cm, x, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
|
2013-05-21 00:59:39 +02:00
|
|
|
vp9_tokenize_sb(cpi, xd, t, !output_enabled,
|
2013-05-11 02:06:37 +02:00
|
|
|
(bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
|
2013-01-10 17:23:59 +01:00
|
|
|
} else {
|
2013-03-04 23:12:17 +01:00
|
|
|
// FIXME(rbultje): not tile-aware (mi - 1)
|
2013-04-09 19:54:19 +02:00
|
|
|
int mb_skip_context =
|
|
|
|
(mi - 1)->mbmi.mb_skip_coeff + (mi - mis)->mbmi.mb_skip_coeff;
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-05-21 00:59:39 +02:00
|
|
|
mbmi->mb_skip_coeff = 1;
|
2013-04-09 19:54:19 +02:00
|
|
|
if (output_enabled)
|
|
|
|
cpi->skip_true_count[mb_skip_context]++;
|
2013-05-11 02:06:37 +02:00
|
|
|
vp9_reset_sb_tokens_context(xd,
|
|
|
|
(bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
|
2013-03-04 23:12:17 +01:00
|
|
|
// copy skip flag on all mb_mode_info contexts in this SB
|
|
|
|
// if this was a skip at this txfm size
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 1; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
2013-04-26 20:57:17 +02:00
|
|
|
if (mi_col + x_idx < cm->mi_cols && mi_row + y_idx < cm->mi_rows)
|
2013-03-04 23:12:17 +01:00
|
|
|
mi[x_idx + y_idx * mis].mbmi.mb_skip_coeff = mi->mbmi.mb_skip_coeff;
|
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
if (output_enabled) {
|
2013-05-24 18:23:15 +02:00
|
|
|
if (cm->txfm_mode == TX_MODE_SELECT &&
|
|
|
|
mbmi->sb_type >= BLOCK_SIZE_SB8X8 &&
|
2013-06-06 22:44:34 +02:00
|
|
|
!(mbmi->ref_frame[0] != INTRA_FRAME && (mbmi->mb_skip_coeff ||
|
2013-05-17 21:50:40 +02:00
|
|
|
vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)))) {
|
2013-04-10 06:28:27 +02:00
|
|
|
if (bsize >= BLOCK_SIZE_SB32X32) {
|
2013-06-06 20:14:04 +02:00
|
|
|
cm->fc.tx_count_32x32p[mbmi->txfm_size]++;
|
2013-05-01 01:13:20 +02:00
|
|
|
} else if (bsize >= BLOCK_SIZE_MB16X16) {
|
2013-06-06 20:14:04 +02:00
|
|
|
cm->fc.tx_count_16x16p[mbmi->txfm_size]++;
|
2013-05-01 01:13:20 +02:00
|
|
|
} else {
|
2013-06-06 20:14:04 +02:00
|
|
|
cm->fc.tx_count_8x8p[mbmi->txfm_size]++;
|
2013-04-10 06:28:27 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
} else {
|
|
|
|
int x, y;
|
2013-03-04 23:12:17 +01:00
|
|
|
TX_SIZE sz = (cm->txfm_mode == TX_MODE_SELECT) ? TX_32X32 : cm->txfm_mode;
|
2013-05-17 21:50:40 +02:00
|
|
|
// The new intra coding scheme requires no change of transform size
|
2013-06-06 22:44:34 +02:00
|
|
|
if (mi->mbmi.ref_frame[0] != INTRA_FRAME) {
|
2013-05-17 21:50:40 +02:00
|
|
|
if (sz == TX_32X32 && bsize < BLOCK_SIZE_SB32X32)
|
|
|
|
sz = TX_16X16;
|
|
|
|
if (sz == TX_16X16 && bsize < BLOCK_SIZE_MB16X16)
|
|
|
|
sz = TX_8X8;
|
|
|
|
if (sz == TX_8X8 && bsize < BLOCK_SIZE_SB8X8)
|
|
|
|
sz = TX_4X4;
|
2013-05-24 20:11:06 +02:00
|
|
|
} else if (bsize >= BLOCK_SIZE_SB8X8) {
|
2013-05-17 21:50:40 +02:00
|
|
|
sz = mbmi->txfm_size;
|
|
|
|
} else {
|
2013-05-02 21:26:00 +02:00
|
|
|
sz = TX_4X4;
|
2013-05-17 21:50:40 +02:00
|
|
|
}
|
2013-04-10 06:28:27 +02:00
|
|
|
|
|
|
|
for (y = 0; y < bh; y++) {
|
|
|
|
for (x = 0; x < bw; x++) {
|
2013-04-26 20:57:17 +02:00
|
|
|
if (mi_col + x < cm->mi_cols && mi_row + y < cm->mi_rows) {
|
2013-01-06 03:20:25 +01:00
|
|
|
mi[mis * y + x].mbmi.txfm_size = sz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-11-08 20:03:00 +01:00
|
|
|
}
|
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|