2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
|
|
#include "math.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "ratectrl.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/entropymode.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_mem/vpx_mem.h"
|
2011-02-10 20:41:38 +01:00
|
|
|
#include "vp8/common/systemdependent.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "encodemv.h"
|
2012-06-15 03:14:43 +02:00
|
|
|
#include "vp8/common/quant_common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-01-11 15:05:57 +01:00
|
|
|
#define MIN_BPB_FACTOR 0.005
|
2010-05-18 17:58:33 +02:00
|
|
|
#define MAX_BPB_FACTOR 50
|
|
|
|
|
|
2012-06-26 01:23:58 +02:00
|
|
|
extern const MODE_DEFINITION vp8_mode_order[MAX_MODES];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef MODE_STATS
|
2012-05-15 01:21:01 +02:00
|
|
|
extern unsigned int y_modes[VP8_YMODES];
|
|
|
|
|
extern unsigned int uv_modes[VP8_UV_MODES];
|
|
|
|
|
extern unsigned int b_modes[B_MODE_COUNT];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-05-15 01:21:01 +02:00
|
|
|
extern unsigned int inter_y_modes[MB_MODE_COUNT];
|
|
|
|
|
extern unsigned int inter_uv_modes[VP8_UV_MODES];
|
|
|
|
|
extern unsigned int inter_b_modes[B_MODE_COUNT];
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// Bits Per MB at different Q (Multiplied by 512)
|
|
|
|
|
#define BPER_MB_NORMBITS 9
|
|
|
|
|
|
|
|
|
|
// % adjustment to target kf size based on seperation from previous frame
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int kf_boost_seperation_adjustment[16] = {
|
|
|
|
|
30, 40, 50, 55, 60, 65, 70, 75,
|
|
|
|
|
80, 85, 90, 95, 100, 100, 100, 100,
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int gf_adjust_table[101] = {
|
|
|
|
|
100,
|
|
|
|
|
115, 130, 145, 160, 175, 190, 200, 210, 220, 230,
|
|
|
|
|
240, 260, 270, 280, 290, 300, 310, 320, 330, 340,
|
|
|
|
|
350, 360, 370, 380, 390, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
|
|
|
|
400, 400, 400, 400, 400, 400, 400, 400, 400, 400,
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int gf_intra_usage_adjustment[20] = {
|
|
|
|
|
125, 120, 115, 110, 105, 100, 95, 85, 80, 75,
|
|
|
|
|
70, 65, 60, 55, 50, 50, 50, 50, 50, 50,
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int gf_interval_table[101] = {
|
|
|
|
|
7,
|
|
|
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
|
|
|
|
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
|
|
|
|
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
|
|
|
|
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
|
|
|
|
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
|
|
|
|
11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 };
|
|
|
|
|
|
2011-11-21 16:45:10 +01:00
|
|
|
// These functions use formulaic calculations to make playing with the
|
|
|
|
|
// quantizer tables easier. If necessary they can be replaced by lookup
|
|
|
|
|
// tables if and when things settle down in the experimental bitstream
|
2012-07-14 00:21:29 +02:00
|
|
|
double vp8_convert_qindex_to_q(int qindex) {
|
|
|
|
|
// Convert the index to a real Q value (scaled down to match old Q values)
|
|
|
|
|
return (double)vp8_ac_yquant(qindex) / 4.0;
|
2011-11-21 16:45:10 +01:00
|
|
|
}
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int vp8_gfboost_qadjust(int qindex) {
|
|
|
|
|
int retval;
|
|
|
|
|
double q;
|
2011-12-06 15:48:52 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
q = vp8_convert_qindex_to_q(qindex);
|
|
|
|
|
retval = (int)((0.00000828 * q * q * q) +
|
|
|
|
|
(-0.0055 * q * q) +
|
|
|
|
|
(1.32 * q) + 79.3);
|
|
|
|
|
return retval;
|
2011-11-21 16:45:10 +01:00
|
|
|
}
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int kfboost_qadjust(int qindex) {
|
|
|
|
|
int retval;
|
|
|
|
|
double q;
|
2011-12-06 15:48:52 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
q = vp8_convert_qindex_to_q(qindex);
|
|
|
|
|
retval = (int)((0.00000973 * q * q * q) +
|
|
|
|
|
(-0.00613 * q * q) +
|
|
|
|
|
(1.316 * q) + 121.2);
|
|
|
|
|
return retval;
|
2011-11-21 16:45:10 +01:00
|
|
|
}
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int vp8_bits_per_mb(FRAME_TYPE frame_type, int qindex) {
|
|
|
|
|
if (frame_type == KEY_FRAME)
|
|
|
|
|
return (int)(4500000 / vp8_convert_qindex_to_q(qindex));
|
|
|
|
|
else
|
|
|
|
|
return (int)(2850000 / vp8_convert_qindex_to_q(qindex));
|
2011-11-21 16:45:10 +01:00
|
|
|
}
|
|
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_save_coding_context(VP8_COMP *cpi) {
|
|
|
|
|
CODING_CONTEXT *const cc = & cpi->coding_context;
|
|
|
|
|
VP8_COMMON *cm = &cpi->common;
|
|
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Stores a snapshot of key state variables which can subsequently be
|
|
|
|
|
// restored with a call to vp8_restore_coding_context. These functions are
|
|
|
|
|
// intended for use in a re-code loop in vp8_compress_frame where the
|
|
|
|
|
// quantizer value is adjusted between loop iterations.
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->mvc, cm->fc.mvc);
|
|
|
|
|
vp8_copy(cc->mvcosts, cpi->mb.mvcosts);
|
2012-02-27 19:22:38 +01:00
|
|
|
#if CONFIG_HIGH_PRECISION_MV
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->mvc_hp, cm->fc.mvc_hp);
|
|
|
|
|
vp8_copy(cc->mvcosts_hp, cpi->mb.mvcosts_hp);
|
2012-02-27 19:22:38 +01:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->mv_ref_ct, cm->fc.mv_ref_ct);
|
|
|
|
|
vp8_copy(cc->mode_context, cm->fc.mode_context);
|
|
|
|
|
vp8_copy(cc->mv_ref_ct_a, cm->fc.mv_ref_ct_a);
|
|
|
|
|
vp8_copy(cc->mode_context_a, cm->fc.mode_context_a);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->ymode_prob, cm->fc.ymode_prob);
|
|
|
|
|
vp8_copy(cc->bmode_prob, cm->fc.bmode_prob);
|
|
|
|
|
vp8_copy(cc->uv_mode_prob, cm->fc.uv_mode_prob);
|
|
|
|
|
vp8_copy(cc->i8x8_mode_prob, cm->fc.i8x8_mode_prob);
|
|
|
|
|
vp8_copy(cc->sub_mv_ref_prob, cm->fc.sub_mv_ref_prob);
|
|
|
|
|
vp8_copy(cc->mbsplit_prob, cm->fc.mbsplit_prob);
|
2012-04-17 18:26:19 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Stats
|
2010-05-18 17:58:33 +02:00
|
|
|
#ifdef MODE_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->y_modes, y_modes);
|
|
|
|
|
vp8_copy(cc->uv_modes, uv_modes);
|
|
|
|
|
vp8_copy(cc->b_modes, b_modes);
|
|
|
|
|
vp8_copy(cc->inter_y_modes, inter_y_modes);
|
|
|
|
|
vp8_copy(cc->inter_uv_modes, inter_uv_modes);
|
|
|
|
|
vp8_copy(cc->inter_b_modes, inter_b_modes);
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->segment_pred_probs, cm->segment_pred_probs);
|
|
|
|
|
vp8_copy(cc->ref_pred_probs_update, cpi->ref_pred_probs_update);
|
|
|
|
|
vp8_copy(cc->ref_pred_probs, cm->ref_pred_probs);
|
|
|
|
|
vp8_copy(cc->prob_comppred, cm->prob_comppred);
|
2012-04-11 16:44:14 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
|
|
|
|
|
cm->last_frame_seg_map, (cm->mb_rows * cm->mb_cols));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->last_ref_lf_deltas, xd->last_ref_lf_deltas);
|
|
|
|
|
vp8_copy(cc->last_mode_lf_deltas, xd->last_mode_lf_deltas);
|
2012-04-11 16:44:14 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cc->coef_probs, cm->fc.coef_probs);
|
|
|
|
|
vp8_copy(cc->coef_probs_8x8, cm->fc.coef_probs_8x8);
|
2012-04-11 16:44:14 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_restore_coding_context(VP8_COMP *cpi) {
|
|
|
|
|
CODING_CONTEXT *const cc = & cpi->coding_context;
|
|
|
|
|
VP8_COMMON *cm = &cpi->common;
|
|
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Restore key state variables to the snapshot state stored in the
|
|
|
|
|
// previous call to vp8_save_coding_context.
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cm->fc.mvc, cc->mvc);
|
|
|
|
|
vp8_copy(cpi->mb.mvcosts, cc->mvcosts);
|
2012-02-27 19:22:38 +01:00
|
|
|
#if CONFIG_HIGH_PRECISION_MV
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cm->fc.mvc_hp, cc->mvc_hp);
|
|
|
|
|
vp8_copy(cpi->mb.mvcosts_hp, cc->mvcosts_hp);
|
2012-02-27 19:22:38 +01:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cm->fc.mv_ref_ct, cc->mv_ref_ct);
|
|
|
|
|
vp8_copy(cm->fc.mode_context, cc->mode_context);
|
|
|
|
|
vp8_copy(cm->fc.mv_ref_ct_a, cc->mv_ref_ct_a);
|
|
|
|
|
vp8_copy(cm->fc.mode_context_a, cc->mode_context_a);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cm->fc.ymode_prob, cc->ymode_prob);
|
|
|
|
|
vp8_copy(cm->fc.bmode_prob, cc->bmode_prob);
|
|
|
|
|
vp8_copy(cm->fc.i8x8_mode_prob, cc->i8x8_mode_prob);
|
|
|
|
|
vp8_copy(cm->fc.uv_mode_prob, cc->uv_mode_prob);
|
|
|
|
|
vp8_copy(cm->fc.sub_mv_ref_prob, cc->sub_mv_ref_prob);
|
|
|
|
|
vp8_copy(cm->fc.mbsplit_prob, cc->mbsplit_prob);
|
2012-04-17 18:26:19 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Stats
|
2010-05-18 17:58:33 +02:00
|
|
|
#ifdef MODE_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(y_modes, cc->y_modes);
|
|
|
|
|
vp8_copy(uv_modes, cc->uv_modes);
|
|
|
|
|
vp8_copy(b_modes, cc->b_modes);
|
|
|
|
|
vp8_copy(inter_y_modes, cc->inter_y_modes);
|
|
|
|
|
vp8_copy(inter_uv_modes, cc->inter_uv_modes);
|
|
|
|
|
vp8_copy(inter_b_modes, cc->inter_b_modes);
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cm->segment_pred_probs, cc->segment_pred_probs);
|
|
|
|
|
vp8_copy(cpi->ref_pred_probs_update, cc->ref_pred_probs_update);
|
|
|
|
|
vp8_copy(cm->ref_pred_probs, cc->ref_pred_probs);
|
|
|
|
|
vp8_copy(cm->prob_comppred, cc->prob_comppred);
|
2012-04-11 16:44:14 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memcpy(cm->last_frame_seg_map,
|
|
|
|
|
cpi->coding_context.last_frame_seg_map_copy,
|
|
|
|
|
(cm->mb_rows * cm->mb_cols));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(xd->last_ref_lf_deltas, cc->last_ref_lf_deltas);
|
|
|
|
|
vp8_copy(xd->last_mode_lf_deltas, cc->last_mode_lf_deltas);
|
2012-04-11 16:44:14 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_copy(cm->fc.coef_probs, cc->coef_probs);
|
|
|
|
|
vp8_copy(cm->fc.coef_probs_8x8, cc->coef_probs_8x8);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_setup_key_frame(VP8_COMP *cpi) {
|
|
|
|
|
// Setup for Key frame:
|
|
|
|
|
vp8_default_coef_probs(& cpi->common);
|
|
|
|
|
vp8_kf_default_bmode_probs(cpi->common.kf_bmode_prob);
|
|
|
|
|
vp8_init_mbmode_probs(& cpi->common);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
|
|
|
|
|
{
|
|
|
|
|
int flag[2] = {1, 1};
|
|
|
|
|
vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag);
|
|
|
|
|
}
|
2012-02-27 19:22:38 +01:00
|
|
|
#if CONFIG_HIGH_PRECISION_MV
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_memcpy(cpi->common.fc.mvc_hp, vp8_default_mv_context_hp, sizeof(vp8_default_mv_context_hp));
|
|
|
|
|
{
|
|
|
|
|
int flag[2] = {1, 1};
|
|
|
|
|
vp8_build_component_cost_table_hp(cpi->mb.mvcost_hp, (const MV_CONTEXT_HP *) cpi->common.fc.mvc_hp, flag);
|
|
|
|
|
}
|
2012-02-27 19:22:38 +01:00
|
|
|
#endif
|
|
|
|
|
|
Improved coding using 8x8 transform
In summary, this commit encompasses a series of changes in attempt to
improve the 8x8 transform based coding to help overall compression
quality, please refer to the detailed commit history below for what
are the rationale underly the series of changes:
a. A frame level flag to indicate if 8x8 transform is used at all.
b. 8x8 transform is not used for key frames and small image size.
c. On inter coded frame, macroblocks using modes B_PRED, SPLIT_MV
and I8X8_PRED are forced to using 4x4 transform based coding, the
rest uses 8x8 transform based coding.
d. Encoder and decoder has the same assumption on the relationship
between prediction modes and transform size, therefore no signaling
is encoded in bitstream.
e. Mode decision process now calculate the rate and distortion scores
using their respective transforms.
Overall test results:
1. HD set
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120206.html
(avg psnr: 3.09% glb psnr: 3.22%, ssim: 3.90%)
2. Cif set:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120206.html
(avg psnr: -0.03%, glb psnr: -0.02%, ssim: -0.04%)
It should be noted here, as 8x8 transform coding itself is disabled
for cif size clips, the 0.03% loss is purely from the 1 bit/frame
flag overhead on if 8x8 transform is used or not for the frame.
---patch history for future reference---
Patch 1:
this commit tries to select transform size based on macroblock
prediction mode. If the size of a prediction mode is 16x16, then
the macroblock is forced to use 8x8 transform. If the prediction
mode is B_PRED, SPLITMV or I8X8_PRED, then the macroblock is forced
to use 4x4 transform. Tests on the following HD clips showed mixed
results: (all hd clips only used first 100 frames in the test)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_log.html
while the results are mixed and overall negative, it is interesting to
see 8x8 helped a few of the clips.
Patch 2:
this patch tries to hard-wire selection of transform size based on
prediction modes without using segmentation to signal the transform size.
encoder and decoder both takes the same assumption that all macroblocks
use 8x8 transform except when prediciton mode is B_PRED, I8X8_PRED or
SPLITMV. Test results are as follows:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cifmodebase8x8_0125.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_0125log.html
Interestingly, by removing the overhead or coding the segmentation, the
results on this limited HD set have turn positive on average.
Patch 3:
this patch disabled the usage of 8x8 transform on key frames, and kept the
logic from patch 2 for inter frames only. test results on HD set turned
decidedly positive with 8x8 transform enabled on inter frame with 16x16
prediction modes: (avg psnr: .81% glb psnr: .82 ssim: .55%)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdintermode8x8_0125.html
results on cif set still negative overall
Patch 4:
continued from last patch, but now in mode decision process, the rate and
distortion estimates are computed based on 8x8 transform results for MBs
with modes associated with 8x8 transform. This patch also fixed a problem
related to segment based eob coding when 8x8 transform is used. The patch
significantly improved the results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hd8x8RDintermode.html
(avg psnr: 2.70% glb psnr: 2.76% ssim: 3.34%)
results on cif also improved, though they are still negative compared to
baseline that uses 4x4 transform only:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif8x8RDintermode.html
(avg psnr: -.78% glb psnr: -.86% ssim: -.19%)
Patch 5:
This patch does 3 things:
a. a bunch of decoder bug fixes, encodings and decodings were verified
to have matched recon buffer on a number of encodes on cif size mobile and
hd version of _pedestrian.
b. the patch further improved the rate distortion calculation of MBS that
use 8x8 transform. This provided some further gain on compression.
c. the patch also got the experimental work SEG_LVL_EOB to work with 8x8
transformed macroblock, test results indicates it improves the cif set
but hurt the HD set slightly.
Tests results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120201.html
(avg psnr: 3.19% glb psnr: 3.30% ssim: 3.93%)
Test results on cif clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120201.html
(avg psnr: -.47% glb psnr: -.51% ssim: +.28%)
Patch 6:
Added a frame level flag to indicate if 8x8 transform is allowed at all.
temporarily the decision is based on frame size, can be optimized later
one. This get the cif results to basically unchanged, with one bit per
frame overhead on both cif and hd clips.
Patch 8:
Rebase and Merge to head by PGW.
Fixed some suspect 4s that look like hey should be 64s in regard
to segmented EOB. Perhaps #defines would be bette.
Bulit and tested without T8x8 enabled and produces unchanged
output.
Patch 9:
Corrected misalligned code/decode of "txfm_mode" bit.
Limited testing for correct encode and decode with
T8x8 configured on derf clips.
Change-Id: I156e1405d25f81579d579dff8ab9af53944ec49c
2012-02-10 01:12:23 +01:00
|
|
|
|
2012-03-19 19:03:27 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->common.txfm_mode = ALLOW_8X8;
|
2012-03-19 19:03:27 +01:00
|
|
|
|
Add lossless compression mode.
This commit adds lossless compression capability to the experimental
branch. The lossless experiment can be enabled using --enable-lossless
in configure. When the experiment is enabled, the encoder will use
lossless compression mode by command line option --lossless, and the
decoder automatically recognizes a losslessly encoded clip and decodes
accordingly.
To achieve the lossless coding, this commit has changed the following:
1. To encode at lossless mode, encoder forces the use of unit
quantizer, i.e, Q 0, where effective quantization is 1. Encoder also
disables the usage of 8x8 transform and allows only 4x4 transform;
2. At Q 0, the first order 4x4 DCT/IDCT have been switched over
to a pair of forward and inverse Walsh-Hadamard Transform
(http://goo.gl/EIsfy), with proper scaling applied to match the range
of the original 4x4 DCT/IDCT pair;
3. At Q 0, the second order remains to use the previous
walsh-hadamard transform pair. However, to maintain the reversibility
in second order transform at Q 0, scaling down is applied to first
order DC coefficients prior to forward transform, and scaling up is
applied to the second order output prior to quantization. Symmetric
upscaling and downscaling are added around inverse second order
transform;
4. At lossless mode, encoder also disables a number of minor
features to ensure no loss is introduced, these features includes:
a. Trellis quantization optimization
b. Loop filtering
c. Aggressive zero-binning, rounding and zero-bin boosting
d. Mode based zero-bin boosting
Lossless coding test was performed on all clips within the derf set,
to verify that the commit has achieved lossless compression for all
clips. The average compression ratio is around 2.57 to 1.
(http://goo.gl/dEShs)
Change-Id: Ia3aba7dd09df40dd590f93b9aba134defbc64e34
2012-06-14 04:03:31 +02:00
|
|
|
#if CONFIG_LOSSLESS
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.lossless)
|
|
|
|
|
cpi->common.txfm_mode = ONLY_4X4;
|
Add lossless compression mode.
This commit adds lossless compression capability to the experimental
branch. The lossless experiment can be enabled using --enable-lossless
in configure. When the experiment is enabled, the encoder will use
lossless compression mode by command line option --lossless, and the
decoder automatically recognizes a losslessly encoded clip and decodes
accordingly.
To achieve the lossless coding, this commit has changed the following:
1. To encode at lossless mode, encoder forces the use of unit
quantizer, i.e, Q 0, where effective quantization is 1. Encoder also
disables the usage of 8x8 transform and allows only 4x4 transform;
2. At Q 0, the first order 4x4 DCT/IDCT have been switched over
to a pair of forward and inverse Walsh-Hadamard Transform
(http://goo.gl/EIsfy), with proper scaling applied to match the range
of the original 4x4 DCT/IDCT pair;
3. At Q 0, the second order remains to use the previous
walsh-hadamard transform pair. However, to maintain the reversibility
in second order transform at Q 0, scaling down is applied to first
order DC coefficients prior to forward transform, and scaling up is
applied to the second order output prior to quantization. Symmetric
upscaling and downscaling are added around inverse second order
transform;
4. At lossless mode, encoder also disables a number of minor
features to ensure no loss is introduced, these features includes:
a. Trellis quantization optimization
b. Loop filtering
c. Aggressive zero-binning, rounding and zero-bin boosting
d. Mode based zero-bin boosting
Lossless coding test was performed on all clips within the derf set,
to verify that the commit has achieved lossless compression for all
clips. The average compression ratio is around 2.57 to 1.
(http://goo.gl/dEShs)
Change-Id: Ia3aba7dd09df40dd590f93b9aba134defbc64e34
2012-06-14 04:03:31 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// cpi->common.filter_level = 0; // Reset every key frame.
|
|
|
|
|
cpi->common.filter_level = cpi->common.base_qindex * 3 / 8;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// interval before next GF
|
|
|
|
|
cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->common.refresh_golden_frame = TRUE;
|
|
|
|
|
cpi->common.refresh_alt_ref_frame = TRUE;
|
2011-12-01 01:36:46 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8_init_mode_contexts(&cpi->common);
|
|
|
|
|
vpx_memcpy(&cpi->common.lfc, &cpi->common.fc, sizeof(cpi->common.fc));
|
|
|
|
|
vpx_memcpy(&cpi->common.lfc_a, &cpi->common.fc, sizeof(cpi->common.fc));
|
2011-12-01 01:36:46 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/*
|
|
|
|
|
vpx_memcpy( cpi->common.fc.vp8_mode_contexts,
|
|
|
|
|
cpi->common.fc.mode_context,
|
|
|
|
|
sizeof(cpi->common.fc.mode_context));
|
|
|
|
|
*/
|
|
|
|
|
vpx_memcpy(cpi->common.fc.vp8_mode_contexts,
|
|
|
|
|
default_vp8_mode_contexts,
|
|
|
|
|
sizeof(default_vp8_mode_contexts));
|
2012-03-15 01:29:39 +01:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_setup_inter_frame(VP8_COMP *cpi) {
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->common.txfm_mode = ALLOW_8X8;
|
Improved coding using 8x8 transform
In summary, this commit encompasses a series of changes in attempt to
improve the 8x8 transform based coding to help overall compression
quality, please refer to the detailed commit history below for what
are the rationale underly the series of changes:
a. A frame level flag to indicate if 8x8 transform is used at all.
b. 8x8 transform is not used for key frames and small image size.
c. On inter coded frame, macroblocks using modes B_PRED, SPLIT_MV
and I8X8_PRED are forced to using 4x4 transform based coding, the
rest uses 8x8 transform based coding.
d. Encoder and decoder has the same assumption on the relationship
between prediction modes and transform size, therefore no signaling
is encoded in bitstream.
e. Mode decision process now calculate the rate and distortion scores
using their respective transforms.
Overall test results:
1. HD set
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120206.html
(avg psnr: 3.09% glb psnr: 3.22%, ssim: 3.90%)
2. Cif set:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120206.html
(avg psnr: -0.03%, glb psnr: -0.02%, ssim: -0.04%)
It should be noted here, as 8x8 transform coding itself is disabled
for cif size clips, the 0.03% loss is purely from the 1 bit/frame
flag overhead on if 8x8 transform is used or not for the frame.
---patch history for future reference---
Patch 1:
this commit tries to select transform size based on macroblock
prediction mode. If the size of a prediction mode is 16x16, then
the macroblock is forced to use 8x8 transform. If the prediction
mode is B_PRED, SPLITMV or I8X8_PRED, then the macroblock is forced
to use 4x4 transform. Tests on the following HD clips showed mixed
results: (all hd clips only used first 100 frames in the test)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_log.html
while the results are mixed and overall negative, it is interesting to
see 8x8 helped a few of the clips.
Patch 2:
this patch tries to hard-wire selection of transform size based on
prediction modes without using segmentation to signal the transform size.
encoder and decoder both takes the same assumption that all macroblocks
use 8x8 transform except when prediciton mode is B_PRED, I8X8_PRED or
SPLITMV. Test results are as follows:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cifmodebase8x8_0125.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_0125log.html
Interestingly, by removing the overhead or coding the segmentation, the
results on this limited HD set have turn positive on average.
Patch 3:
this patch disabled the usage of 8x8 transform on key frames, and kept the
logic from patch 2 for inter frames only. test results on HD set turned
decidedly positive with 8x8 transform enabled on inter frame with 16x16
prediction modes: (avg psnr: .81% glb psnr: .82 ssim: .55%)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdintermode8x8_0125.html
results on cif set still negative overall
Patch 4:
continued from last patch, but now in mode decision process, the rate and
distortion estimates are computed based on 8x8 transform results for MBs
with modes associated with 8x8 transform. This patch also fixed a problem
related to segment based eob coding when 8x8 transform is used. The patch
significantly improved the results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hd8x8RDintermode.html
(avg psnr: 2.70% glb psnr: 2.76% ssim: 3.34%)
results on cif also improved, though they are still negative compared to
baseline that uses 4x4 transform only:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif8x8RDintermode.html
(avg psnr: -.78% glb psnr: -.86% ssim: -.19%)
Patch 5:
This patch does 3 things:
a. a bunch of decoder bug fixes, encodings and decodings were verified
to have matched recon buffer on a number of encodes on cif size mobile and
hd version of _pedestrian.
b. the patch further improved the rate distortion calculation of MBS that
use 8x8 transform. This provided some further gain on compression.
c. the patch also got the experimental work SEG_LVL_EOB to work with 8x8
transformed macroblock, test results indicates it improves the cif set
but hurt the HD set slightly.
Tests results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120201.html
(avg psnr: 3.19% glb psnr: 3.30% ssim: 3.93%)
Test results on cif clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120201.html
(avg psnr: -.47% glb psnr: -.51% ssim: +.28%)
Patch 6:
Added a frame level flag to indicate if 8x8 transform is allowed at all.
temporarily the decision is based on frame size, can be optimized later
one. This get the cif results to basically unchanged, with one bit per
frame overhead on both cif and hd clips.
Patch 8:
Rebase and Merge to head by PGW.
Fixed some suspect 4s that look like hey should be 64s in regard
to segmented EOB. Perhaps #defines would be bette.
Bulit and tested without T8x8 enabled and produces unchanged
output.
Patch 9:
Corrected misalligned code/decode of "txfm_mode" bit.
Limited testing for correct encode and decode with
T8x8 configured on derf clips.
Change-Id: I156e1405d25f81579d579dff8ab9af53944ec49c
2012-02-10 01:12:23 +01:00
|
|
|
|
Add lossless compression mode.
This commit adds lossless compression capability to the experimental
branch. The lossless experiment can be enabled using --enable-lossless
in configure. When the experiment is enabled, the encoder will use
lossless compression mode by command line option --lossless, and the
decoder automatically recognizes a losslessly encoded clip and decodes
accordingly.
To achieve the lossless coding, this commit has changed the following:
1. To encode at lossless mode, encoder forces the use of unit
quantizer, i.e, Q 0, where effective quantization is 1. Encoder also
disables the usage of 8x8 transform and allows only 4x4 transform;
2. At Q 0, the first order 4x4 DCT/IDCT have been switched over
to a pair of forward and inverse Walsh-Hadamard Transform
(http://goo.gl/EIsfy), with proper scaling applied to match the range
of the original 4x4 DCT/IDCT pair;
3. At Q 0, the second order remains to use the previous
walsh-hadamard transform pair. However, to maintain the reversibility
in second order transform at Q 0, scaling down is applied to first
order DC coefficients prior to forward transform, and scaling up is
applied to the second order output prior to quantization. Symmetric
upscaling and downscaling are added around inverse second order
transform;
4. At lossless mode, encoder also disables a number of minor
features to ensure no loss is introduced, these features includes:
a. Trellis quantization optimization
b. Loop filtering
c. Aggressive zero-binning, rounding and zero-bin boosting
d. Mode based zero-bin boosting
Lossless coding test was performed on all clips within the derf set,
to verify that the commit has achieved lossless compression for all
clips. The average compression ratio is around 2.57 to 1.
(http://goo.gl/dEShs)
Change-Id: Ia3aba7dd09df40dd590f93b9aba134defbc64e34
2012-06-14 04:03:31 +02:00
|
|
|
#if CONFIG_LOSSLESS
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.lossless)
|
|
|
|
|
cpi->common.txfm_mode = ONLY_4X4;
|
Add lossless compression mode.
This commit adds lossless compression capability to the experimental
branch. The lossless experiment can be enabled using --enable-lossless
in configure. When the experiment is enabled, the encoder will use
lossless compression mode by command line option --lossless, and the
decoder automatically recognizes a losslessly encoded clip and decodes
accordingly.
To achieve the lossless coding, this commit has changed the following:
1. To encode at lossless mode, encoder forces the use of unit
quantizer, i.e, Q 0, where effective quantization is 1. Encoder also
disables the usage of 8x8 transform and allows only 4x4 transform;
2. At Q 0, the first order 4x4 DCT/IDCT have been switched over
to a pair of forward and inverse Walsh-Hadamard Transform
(http://goo.gl/EIsfy), with proper scaling applied to match the range
of the original 4x4 DCT/IDCT pair;
3. At Q 0, the second order remains to use the previous
walsh-hadamard transform pair. However, to maintain the reversibility
in second order transform at Q 0, scaling down is applied to first
order DC coefficients prior to forward transform, and scaling up is
applied to the second order output prior to quantization. Symmetric
upscaling and downscaling are added around inverse second order
transform;
4. At lossless mode, encoder also disables a number of minor
features to ensure no loss is introduced, these features includes:
a. Trellis quantization optimization
b. Loop filtering
c. Aggressive zero-binning, rounding and zero-bin boosting
d. Mode based zero-bin boosting
Lossless coding test was performed on all clips within the derf set,
to verify that the commit has achieved lossless compression for all
clips. The average compression ratio is around 2.57 to 1.
(http://goo.gl/dEShs)
Change-Id: Ia3aba7dd09df40dd590f93b9aba134defbc64e34
2012-06-14 04:03:31 +02:00
|
|
|
#endif
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->common.refresh_alt_ref_frame) {
|
|
|
|
|
vpx_memcpy(&cpi->common.fc,
|
|
|
|
|
&cpi->common.lfc_a,
|
|
|
|
|
sizeof(cpi->common.fc));
|
|
|
|
|
vpx_memcpy(cpi->common.fc.vp8_mode_contexts,
|
|
|
|
|
cpi->common.fc.mode_context_a,
|
|
|
|
|
sizeof(cpi->common.fc.vp8_mode_contexts));
|
|
|
|
|
} else {
|
|
|
|
|
vpx_memcpy(&cpi->common.fc,
|
|
|
|
|
&cpi->common.lfc,
|
|
|
|
|
sizeof(cpi->common.fc));
|
|
|
|
|
vpx_memcpy(cpi->common.fc.vp8_mode_contexts,
|
|
|
|
|
cpi->common.fc.mode_context,
|
|
|
|
|
sizeof(cpi->common.fc.vp8_mode_contexts));
|
|
|
|
|
}
|
2011-12-01 01:36:46 +01:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2011-04-25 21:02:54 +02:00
|
|
|
|
2011-04-26 22:45:30 +02:00
|
|
|
static int estimate_bits_at_q(int frame_kind, int Q, int MBs,
|
2012-07-14 00:21:29 +02:00
|
|
|
double correction_factor) {
|
|
|
|
|
int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb(frame_kind, Q));
|
|
|
|
|
|
|
|
|
|
/* Attempt to retain reasonable accuracy without overflow. The cutoff is
|
|
|
|
|
* chosen such that the maximum product of Bpm and MBs fits 31 bits. The
|
|
|
|
|
* largest Bpm takes 20 bits.
|
|
|
|
|
*/
|
|
|
|
|
if (MBs > (1 << 11))
|
|
|
|
|
return (Bpm >> BPER_MB_NORMBITS) * MBs;
|
|
|
|
|
else
|
|
|
|
|
return (Bpm * MBs) >> BPER_MB_NORMBITS;
|
2011-04-26 22:45:30 +02:00
|
|
|
}
|
2011-04-25 21:02:54 +02:00
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void calc_iframe_target_size(VP8_COMP *cpi) {
|
|
|
|
|
// boost defaults to half second
|
|
|
|
|
int target;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Clear down mmx registers to allow floating point in what follows
|
|
|
|
|
vp8_clear_system_state(); // __asm emms;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// New Two pass RC
|
|
|
|
|
target = cpi->per_frame_bandwidth;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.rc_max_intra_bitrate_pct) {
|
|
|
|
|
unsigned int max_rate = cpi->per_frame_bandwidth
|
|
|
|
|
* cpi->oxcf.rc_max_intra_bitrate_pct / 100;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (target > max_rate)
|
|
|
|
|
target = max_rate;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->this_frame_target = target;
|
2011-04-26 22:45:30 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2011-04-26 22:45:30 +02:00
|
|
|
|
2012-02-17 17:29:03 +01:00
|
|
|
// Do the best we can to define the parameteres for the next GF based
|
|
|
|
|
// on what information we have available.
|
2012-02-25 00:27:59 +01:00
|
|
|
//
|
|
|
|
|
// In this experimental code only two pass is supported
|
|
|
|
|
// so we just use the interval determined in the two pass code.
|
2012-07-14 00:21:29 +02:00
|
|
|
static void calc_gf_params(VP8_COMP *cpi) {
|
|
|
|
|
// Set the gf interval
|
|
|
|
|
cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void calc_pframe_target_size(VP8_COMP *cpi) {
|
|
|
|
|
int min_frame_target;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
min_frame_target = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
min_frame_target = cpi->min_frame_bandwidth;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
|
|
|
|
|
min_frame_target = cpi->av_per_frame_bandwidth >> 5;
|
2011-08-12 20:51:36 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Special alt reference frame case
|
|
|
|
|
if (cpi->common.refresh_alt_ref_frame) {
|
|
|
|
|
// Per frame bit target for the alt ref frame
|
|
|
|
|
cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
|
|
|
|
|
cpi->this_frame_target = cpi->per_frame_bandwidth;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Normal frames (gf,and inter)
|
|
|
|
|
else {
|
|
|
|
|
cpi->this_frame_target = cpi->per_frame_bandwidth;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Sanity check that the total sum of adjustments is not above the maximum allowed
|
|
|
|
|
// That is that having allowed for KF and GF penalties we have not pushed the
|
|
|
|
|
// current interframe target to low. If the adjustment we apply here is not capable of recovering
|
|
|
|
|
// all the extra bits we have spent in the KF or GF then the remainder will have to be recovered over
|
|
|
|
|
// a longer time span via other buffer / rate control mechanisms.
|
|
|
|
|
if (cpi->this_frame_target < min_frame_target)
|
|
|
|
|
cpi->this_frame_target = min_frame_target;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!cpi->common.refresh_alt_ref_frame)
|
|
|
|
|
// Note the baseline target data rate for this inter frame.
|
|
|
|
|
cpi->inter_frame_target = cpi->this_frame_target;
|
|
|
|
|
|
|
|
|
|
// Adjust target frame size for Golden Frames:
|
|
|
|
|
if (cpi->frames_till_gf_update_due == 0) {
|
|
|
|
|
// int Boost = 0;
|
|
|
|
|
int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
|
|
|
|
|
|
|
|
|
|
cpi->common.refresh_golden_frame = TRUE;
|
2012-02-25 00:27:59 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
calc_gf_params(cpi);
|
|
|
|
|
|
|
|
|
|
// If we are using alternate ref instead of gf then do not apply the boost
|
|
|
|
|
// It will instead be applied to the altref update
|
|
|
|
|
// Jims modified boost
|
|
|
|
|
if (!cpi->source_alt_ref_active) {
|
|
|
|
|
if (cpi->oxcf.fixed_q < 0) {
|
|
|
|
|
// The spend on the GF is defined in the two pass code
|
|
|
|
|
// for two pass encodes
|
|
|
|
|
cpi->this_frame_target = cpi->per_frame_bandwidth;
|
|
|
|
|
} else
|
|
|
|
|
cpi->this_frame_target =
|
|
|
|
|
(estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0)
|
|
|
|
|
* cpi->last_boost) / 100;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
// If there is an active ARF at this location use the minimum
|
|
|
|
|
// bits on this frame even if it is a contructed arf.
|
|
|
|
|
// The active maximum quantizer insures that an appropriate
|
|
|
|
|
// number of bits will be spent if needed for contstructed ARFs.
|
|
|
|
|
else {
|
|
|
|
|
cpi->this_frame_target = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
cpi->current_gf_interval = cpi->frames_till_gf_update_due;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var) {
|
|
|
|
|
int Q = cpi->common.base_qindex;
|
|
|
|
|
int correction_factor = 100;
|
|
|
|
|
double rate_correction_factor;
|
|
|
|
|
double adjustment_limit;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int projected_size_based_on_q = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Clear down mmx registers to allow floating point in what follows
|
|
|
|
|
vp8_clear_system_state(); // __asm emms;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->common.frame_type == KEY_FRAME) {
|
|
|
|
|
rate_correction_factor = cpi->key_frame_rate_correction_factor;
|
|
|
|
|
} else {
|
|
|
|
|
if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
|
|
|
|
|
rate_correction_factor = cpi->gf_rate_correction_factor;
|
2010-05-18 17:58:33 +02:00
|
|
|
else
|
2012-07-14 00:21:29 +02:00
|
|
|
rate_correction_factor = cpi->rate_correction_factor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Work out how big we would have expected the frame to be at this Q given the current correction factor.
|
|
|
|
|
// Stay in double to avoid int overflow when values are large
|
|
|
|
|
projected_size_based_on_q =
|
|
|
|
|
(int)(((.5 + rate_correction_factor *
|
|
|
|
|
vp8_bits_per_mb(cpi->common.frame_type, Q)) *
|
|
|
|
|
cpi->common.MBs) / (1 << BPER_MB_NORMBITS));
|
|
|
|
|
|
|
|
|
|
// Make some allowance for cpi->zbin_over_quant
|
|
|
|
|
if (cpi->zbin_over_quant > 0) {
|
|
|
|
|
int Z = cpi->zbin_over_quant;
|
|
|
|
|
double Factor = 0.99;
|
|
|
|
|
double factor_adjustment = 0.01 / 256.0; // (double)ZBIN_OQ_MAX;
|
|
|
|
|
|
|
|
|
|
while (Z > 0) {
|
|
|
|
|
Z--;
|
|
|
|
|
projected_size_based_on_q =
|
|
|
|
|
(int)(Factor * projected_size_based_on_q);
|
|
|
|
|
Factor += factor_adjustment;
|
|
|
|
|
|
|
|
|
|
if (Factor >= 0.999)
|
|
|
|
|
Factor = 0.999;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Work out a size correction factor.
|
|
|
|
|
// if ( cpi->this_frame_target > 0 )
|
|
|
|
|
// correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target;
|
|
|
|
|
if (projected_size_based_on_q > 0)
|
|
|
|
|
correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// More heavily damped adjustment used if we have been oscillating either side of target
|
|
|
|
|
switch (damp_var) {
|
2010-05-18 17:58:33 +02:00
|
|
|
case 0:
|
2012-07-14 00:21:29 +02:00
|
|
|
adjustment_limit = 0.75;
|
|
|
|
|
break;
|
2010-05-18 17:58:33 +02:00
|
|
|
case 1:
|
2012-07-14 00:21:29 +02:00
|
|
|
adjustment_limit = 0.375;
|
|
|
|
|
break;
|
2010-05-18 17:58:33 +02:00
|
|
|
case 2:
|
|
|
|
|
default:
|
2012-07-14 00:21:29 +02:00
|
|
|
adjustment_limit = 0.25;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
|
|
|
|
|
if (correction_factor > 102) {
|
|
|
|
|
// We are not already at the worst allowable quality
|
|
|
|
|
correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit));
|
|
|
|
|
rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
|
|
|
|
|
|
|
|
|
|
// Keep rate_correction_factor within limits
|
|
|
|
|
if (rate_correction_factor > MAX_BPB_FACTOR)
|
|
|
|
|
rate_correction_factor = MAX_BPB_FACTOR;
|
|
|
|
|
}
|
|
|
|
|
// else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) )
|
|
|
|
|
else if (correction_factor < 99) {
|
|
|
|
|
// We are not already at the best allowable quality
|
|
|
|
|
correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit));
|
|
|
|
|
rate_correction_factor = ((rate_correction_factor * correction_factor) / 100);
|
|
|
|
|
|
|
|
|
|
// Keep rate_correction_factor within limits
|
|
|
|
|
if (rate_correction_factor < MIN_BPB_FACTOR)
|
|
|
|
|
rate_correction_factor = MIN_BPB_FACTOR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (cpi->common.frame_type == KEY_FRAME)
|
|
|
|
|
cpi->key_frame_rate_correction_factor = rate_correction_factor;
|
|
|
|
|
else {
|
|
|
|
|
if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
|
|
|
|
|
cpi->gf_rate_correction_factor = rate_correction_factor;
|
2010-05-18 17:58:33 +02:00
|
|
|
else
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->rate_correction_factor = rate_correction_factor;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame) {
|
|
|
|
|
int Q = cpi->active_worst_quality;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int i;
|
|
|
|
|
int last_error = INT_MAX;
|
|
|
|
|
int target_bits_per_mb;
|
|
|
|
|
int bits_per_mb_at_this_q;
|
|
|
|
|
double correction_factor;
|
2012-02-25 00:27:59 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Reset Zbin OQ value
|
|
|
|
|
cpi->zbin_over_quant = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Select the appropriate correction factor based upon type of frame.
|
|
|
|
|
if (cpi->common.frame_type == KEY_FRAME)
|
|
|
|
|
correction_factor = cpi->key_frame_rate_correction_factor;
|
|
|
|
|
else {
|
|
|
|
|
if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame)
|
|
|
|
|
correction_factor = cpi->gf_rate_correction_factor;
|
2010-05-18 17:58:33 +02:00
|
|
|
else
|
2012-07-14 00:21:29 +02:00
|
|
|
correction_factor = cpi->rate_correction_factor;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate required scaling factor based on target frame size and size of frame produced using previous Q
|
|
|
|
|
if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
|
|
|
|
|
target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS; // Case where we would overflow int
|
|
|
|
|
else
|
|
|
|
|
target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
i = cpi->active_best_quality;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
do {
|
|
|
|
|
bits_per_mb_at_this_q =
|
|
|
|
|
(int)(.5 + correction_factor *
|
|
|
|
|
vp8_bits_per_mb(cpi->common.frame_type, i));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (bits_per_mb_at_this_q <= target_bits_per_mb) {
|
|
|
|
|
if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
|
|
|
|
|
Q = i;
|
|
|
|
|
else
|
|
|
|
|
Q = i - 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
break;
|
|
|
|
|
} else
|
|
|
|
|
last_error = bits_per_mb_at_this_q - target_bits_per_mb;
|
|
|
|
|
} while (++i <= cpi->active_worst_quality);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// If we are at MAXQ then enable Q over-run which seeks to claw back additional bits through things like
|
|
|
|
|
// the RD multiplier and zero bin size.
|
|
|
|
|
if (Q >= MAXQ) {
|
|
|
|
|
int zbin_oqmax;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
double Factor = 0.99;
|
|
|
|
|
double factor_adjustment = 0.01 / 256.0; // (double)ZBIN_OQ_MAX;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->common.frame_type == KEY_FRAME)
|
|
|
|
|
zbin_oqmax = 0; // ZBIN_OQ_MAX/16
|
|
|
|
|
else if (cpi->common.refresh_alt_ref_frame || (cpi->common.refresh_golden_frame && !cpi->source_alt_ref_active))
|
|
|
|
|
zbin_oqmax = 16;
|
|
|
|
|
else
|
|
|
|
|
zbin_oqmax = ZBIN_OQ_MAX;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Each incrment in the zbin is assumed to have a fixed effect on bitrate. This is not of course true.
|
|
|
|
|
// The effect will be highly clip dependent and may well have sudden steps.
|
|
|
|
|
// The idea here is to acheive higher effective quantizers than the normal maximum by expanding the zero
|
|
|
|
|
// bin and hence decreasing the number of low magnitude non zero coefficients.
|
|
|
|
|
while (cpi->zbin_over_quant < zbin_oqmax) {
|
|
|
|
|
cpi->zbin_over_quant++;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->zbin_over_quant > zbin_oqmax)
|
|
|
|
|
cpi->zbin_over_quant = zbin_oqmax;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Adjust bits_per_mb_at_this_q estimate
|
|
|
|
|
bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
|
|
|
|
|
Factor += factor_adjustment;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (Factor >= 0.999)
|
|
|
|
|
Factor = 0.999;
|
2012-02-25 00:27:59 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (bits_per_mb_at_this_q <= target_bits_per_mb) // Break out if we get down to the target rate
|
|
|
|
|
break;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return Q;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2011-04-19 22:08:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static int estimate_keyframe_frequency(VP8_COMP *cpi) {
|
|
|
|
|
int i;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Average key frame frequency
|
|
|
|
|
int av_key_frame_frequency = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* First key frame at start of sequence is a special case. We have no
|
|
|
|
|
* frequency data.
|
|
|
|
|
*/
|
|
|
|
|
if (cpi->key_frame_count == 1) {
|
|
|
|
|
/* Assume a default of 1 kf every 2 seconds, or the max kf interval,
|
|
|
|
|
* whichever is smaller.
|
2011-04-19 22:08:45 +02:00
|
|
|
*/
|
2012-07-14 00:21:29 +02:00
|
|
|
int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
|
|
|
|
|
av_key_frame_frequency = (int)cpi->output_frame_rate * 2;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
|
|
|
|
|
av_key_frame_frequency = cpi->oxcf.key_freq;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
|
|
|
|
|
= av_key_frame_frequency;
|
|
|
|
|
} else {
|
|
|
|
|
unsigned int total_weight = 0;
|
|
|
|
|
int last_kf_interval =
|
|
|
|
|
(cpi->frames_since_key > 0) ? cpi->frames_since_key : 1;
|
|
|
|
|
|
|
|
|
|
/* reset keyframe context and calculate weighted average of last
|
|
|
|
|
* KEY_FRAME_CONTEXT keyframes
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < KEY_FRAME_CONTEXT; i++) {
|
|
|
|
|
if (i < KEY_FRAME_CONTEXT - 1)
|
|
|
|
|
cpi->prior_key_frame_distance[i]
|
|
|
|
|
= cpi->prior_key_frame_distance[i + 1];
|
|
|
|
|
else
|
|
|
|
|
cpi->prior_key_frame_distance[i] = last_kf_interval;
|
|
|
|
|
|
|
|
|
|
av_key_frame_frequency += prior_key_frame_weight[i]
|
|
|
|
|
* cpi->prior_key_frame_distance[i];
|
|
|
|
|
total_weight += prior_key_frame_weight[i];
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
av_key_frame_frequency /= total_weight;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
return av_key_frame_frequency;
|
2011-04-19 22:08:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_adjust_key_frame_context(VP8_COMP *cpi) {
|
|
|
|
|
// Clear down mmx registers to allow floating point in what follows
|
|
|
|
|
vp8_clear_system_state();
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->frames_since_key = 0;
|
|
|
|
|
cpi->key_frame_count++;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2011-04-19 22:08:45 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit) {
|
|
|
|
|
// Set-up bounds on acceptable frame size:
|
|
|
|
|
if (cpi->oxcf.fixed_q >= 0) {
|
|
|
|
|
// Fixed Q scenario: frame size never outranges target (there is no target!)
|
|
|
|
|
*frame_under_shoot_limit = 0;
|
|
|
|
|
*frame_over_shoot_limit = INT_MAX;
|
|
|
|
|
} else {
|
|
|
|
|
if (cpi->common.frame_type == KEY_FRAME) {
|
|
|
|
|
*frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
|
|
|
|
|
*frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
|
|
|
|
|
} else {
|
|
|
|
|
if (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame) {
|
|
|
|
|
*frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
|
|
|
|
|
*frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
|
|
|
|
|
} else {
|
|
|
|
|
// Stron overshoot limit for constrained quality
|
|
|
|
|
if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
|
|
|
|
|
*frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
|
|
|
|
|
*frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
|
|
|
|
|
} else {
|
|
|
|
|
*frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
|
|
|
|
|
*frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
// For very small rate targets where the fractional adjustment
|
|
|
|
|
// (eg * 7/8) may be tiny make sure there is at least a minimum
|
|
|
|
|
// range.
|
|
|
|
|
*frame_over_shoot_limit += 200;
|
|
|
|
|
*frame_under_shoot_limit -= 200;
|
|
|
|
|
if (*frame_under_shoot_limit < 0)
|
|
|
|
|
*frame_under_shoot_limit = 0;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2011-04-25 21:02:54 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
// return of 0 means drop frame
|
2012-07-14 00:21:29 +02:00
|
|
|
int vp8_pick_frame_size(VP8_COMP *cpi) {
|
|
|
|
|
VP8_COMMON *cm = &cpi->common;
|
2011-04-25 21:02:54 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->frame_type == KEY_FRAME)
|
|
|
|
|
calc_iframe_target_size(cpi);
|
|
|
|
|
else
|
|
|
|
|
calc_pframe_target_size(cpi);
|
2011-04-25 21:02:54 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return 1;
|
2011-04-25 21:02:54 +02:00
|
|
|
}
|