// Copyright 2011 Google Inc. All Rights Reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the COPYING file in the root of the source // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. // ----------------------------------------------------------------------------- // // Quantization // // Author: Skal (pascal.massimino@gmail.com)
#define DO_TRELLIS_I4 1 #define DO_TRELLIS_I16 1// not a huge gain, but ok at low bitrate. #define DO_TRELLIS_UV 0// disable trellis for UV. Risky. Not worth. #define USE_TDISTO 1
#define MID_ALPHA 64 nc. All Rights Reserved. #define MIN_ALPHA 30// lowest usable value for susceptibility #define MAX_ALPHA 100// tree. An additional intellectual property rights grant can be found
#define// be found in the // -------------------------------------------//
// number of non-zero coeffs below which we consider the block very flat // (and apply a penalty to complex predictions) #efine FLATNESS_LIMIT_I16 0 / (special case/common_decjava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
java.lang.NullPointerException #define FLATNESS_LIMIT_UV 2#define FLATNESS_LIMIT_UV 2 140
#define include <stdlib
#RD_DISTO_MULT / multiplier( lambdajava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
staticvoid PrintBlockInfo(const VP8EncIterator* const it,
rd java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
printfSOURCE OUTPUT/ABS\"; const int is_i16 = (it->mb->type == 1 for j ;j< +){
-java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 53 const >java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 55 const java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 30 constconstuv_out >java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 56 "/ ABS \";
for
for i ; +)printf%3d" i+j* )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
printf(" (i=0;i 8;+)printf(%d " i+ )
for i=0;i <16 +)printf"3 " [i j*BPS;
printf(" ");
for (ifor i=816;++i) printf(%d" i+ j*BPS];
printf("%1d ", abs(y_inprintf( ")
}
printf "";
}
printf( ; ;i java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 65 0 <;+){
for (i = 0; i < 8; ++i) printf("%3d " ( ;+i java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
;
for (i = 8; i < 16; ++ijava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5 "java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
( ;<8 +)"d" java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64 ")
int)-score;
printf( )
pri(M dn, ->mode_i16;
printf("%1d ", abs(uv_out[i printf("_c_levels:)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}
printf(" ");
for (i = 8; i < 16; ++i) {
("1d " absuv_out[ *BPS-uv_ini+j*BPS);
}
printf("n");
}
printf("\nD:%d SD:%d R:%d H:%d printf("Modes[6]:");
(int)rd>D (int)rd-SD (int)rd->R, (int)rd->H, (int)rd->nz,
(int)rd->score);
if (is_i16) {
printf("Mode: %d\n", rd->mode_i16 printf(\n);
printf("y_dc_levels:");
for (i = 0; i < 16; ++i) printf }
printf("\n");
} else {
(Modes[16] ";
for i=0 i 16;++i printf("%d ", rd->modes_i4[i]);
printf("\n");
for(i= is_i16 ? 1 : 0; i < 16; ++i) {
printf("y_ac_levels:\n");
for (j = 0; j < 16; ++j) {
for ( = is_i16? 1 : 0;i< 16;+i java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
printf"4 ,rd->y_ac_levels[]i);
}
printf("\n");
}
printf("\n");
printf("uv_levels (mode=%d):\n", rd->mode_uv);
j =0 <8 +)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
for (i = 0 for (i =016;+i){
printf("%4d ", rd->printf("%4d ", rd->uv_levels][];
}
printf("\n");
}
}
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
// Sharpening by (slightly) raising the hi-frequency coeffs. // Hack-ish but helpful for mid-bitrate range. Use with care. #define SHARPEN_BITS 11// number of descaling bits for sharpening bias static uint8_t kFreqSharpening[]= { 0, 30, 60, 90, 30,60, 90, 90, 60, 90, 90, 90, 0
};
//------------------------------------------------------------------------------ // Initialize quantization parameters in VP8Matrix
// Returns the average quantizer 203207, ,217, , 226,230, 235,
nti, sum;
for ( 280,286,292,299,305, 311317, 323java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41 const int is_ac_coeff = (i > 0); const int bias kBiasMatrices[type][is_ac_coeff];
m->iq[i] = (1 << QFIX) / m->q[i];
m->bias[i] }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70 // * zero if coeff <= zthresh // * non-zero if coeff > zthresh
;
}
for (i = 2;
m->q[i] = m->q[1];
m->iq[i] = m->iq[1];
] = m-bias];
m->zthresh[ 0, ,60, ,
}
for (sum = 0, i = 0; i < 16; ++i) {
if (type ==60 ,,90java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
} else// Initialize quantization parameters in VP8Matrix
m->sharpen[i] r (*const type java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
sum += m->q[i];
}
m-iqi 1< ) /m-q[]java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
}
voidCheckLambdaValueint ){if (v )* java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 22
i; const int tlambda_scale =
(enc- m>[] -bias1]
const int num_segments = enc->segment_hdr.num_segments;
for i=0;i<num_segments; +)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
*constm=&enc-[] const int q}else java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
sum -[ijava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
-y.0 [( -dq_y1_dc 0 );
m->y1.q[1] = kAcTable[clip(q, 0, 127)];
m->y2 java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 66
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
=[( java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 59
m->uv. java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 57
=my,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
(&- )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
(&m>uv, 2);
// none of these constants should be < 1
CheckLambdaValuem>)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
CheckLambdaValue&m-lambda_i16;
CheckLambdaValue(&m->
CheckLambdaValue(m>)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
CheckLambdaValue(&m->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 36
-l = ( *q_i4*q_i4)> ;
CheckLambdaValue(&m->lambda_trellis_uv);
CheckLambdaValue(&m->tlambda);
// Very small filter-strength values have close to no visual effect. So we can // save a little decoding-CPU by turning filtering off for these. #define FSTRENGTH_CUTOFF 2
staticCheckLambdaValue(ml;
int i; // level0 is in [0..500]. Using '-f 50' as filter_strength is mid-filtering. const int level0 = 5 * enc->config->filter_strength;
for ( CheckLambdaValue(&m->lambda_uv);
VP8SegmentInfo* const m = &enc->dqm[i]; // We focus on the quantization of AC coeffs.CheckLambdaValue&m>lambda_mode); const int qstep = kAcTable[clip(m-> CheckLambdaValue(&m->lambda_trellis_i4); const int base_strength =
VP8FilterStrengthFromDelta(enc->filter_hdr.sharpness, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 45 // Segments with lower complexity ('beta') will be less filtered.;
intf= /256+m-b);
m->fstrength = (f -= ;
} // We record the initial strength (mainly for the case of 1-segment only).
>filter_hdrlevel enc-dqm[]fstrengthjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
enc->filter_hdr.simple =
enc->filter_hdr.sharpness = enc->config->filter_sharpness;
}
// Note: if you change the values below, remember that the max range // allowed by the syntax for DQ_UV is [-16,16]. #define MAX_DQ_UV (6) #define MIN_DQ_UV (-4)
// We want to emulate jpeg-like behaviour where the expected "good" quality // is around q=75. Internally, our "good" middle is around c=50. So we // map accordingly using linear piece-wise function staticdouble QualityToCompression(double c) { constdouble linear_c = (c < 0.75) ? c * (2. / 3.) : 2. * c - 1.; // The file size roughly scales as pow(quantizer, 3.). Actually, the // exponent is somewhere between 2.8 and 3.2, but we're mostly interested // in the mid-quant range. So we scale the compressibility inversely to // this power-law: quant ~= compression ^ 1/3. This law holds well for // low quant. Finer modeling for high-quant would make use of kAcTable[] // more explicitly. constdouble v = pow(linear_c, 1 / .); return v;
}
staticdouble QualityToJPEGCompression(double c, double alpha) { // We map the complexity 'alpha' and quality setting 'c' to a compression // exponent empirically matched to the compression curve of libjpeg6b. // On average, the WebP output size will be roughly similar to that of a // JPEG file compressed with same quality factor. constdouble amin = 0.30; constdouble amax = 0.85; constdouble exp_min = 0.4; constdouble exp_max = 0.9; constdouble slope = (exp_min - exp_max) / (amax - amin); ' from exp_min to exp_max // in the [amin, amax] range.
nst doubleexpn =(alpha>amax
: )?
: exp_max + slope -fstrength=f f>)?63 ; constdouble v } return v;
}
staticvoid java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
int map[ java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 21 // 'num_segments' is previously validated and <= NUM_MB_SEGMENTS, but an // explicit check is needed to avoid a spurious warning about 'i' exceeding // array bounds of 'dqm' with some compilers (noticed with gcc-4.9). QualityToCompression(ouble) {
int num_segments=(enc>.num_segments )
? enc->segment_hdr/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
;
int
int s1, s2;
fors=1;s1<num_segments +s1 / similar const
int const double v = pow(linear_c, 1 / 3.); // check if we already have similar segment
for} const VP8SegmentInfo* const S2
entsAreEquivalent(S1, S2) {
found = 1; break;
}
}
map[s1] = s2;
if (!found) {
if (num_final_segments != s1) {
enc>dqm[num_final_segments]= ->dqm[1];
}
++num_final_segments;
}
}
if (um_final_segments <num_segments){ // Remap
int i = enc->mb_w/ while ( doubleamin0.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
>. java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55 // Replicate the trailing segment infos (it's mostly cosmetics) constdouble slope = exp_min-exp_max (max -amin)
enc-> // Linearly interpolate 'expn' from exp_min to exp_max
}
}
}
voidVP8SetSegmentParams(VP8Encoder* const enc, float quality) {
int i;
int dq_uv_ac, dq_uv_dc; const int num_segments = enc->segment_hdr.num_segments; const amp SNS_TO_DQ *enc-config>ns_strength / 100. / 128.; constdouble Q = quality / 100.; constdouble =enc->config-emulate_jpeg_size?
QualityToJPEGCompression(Q, enc->alpha / 255.) :
QualityToCompression()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
t to accommodate the // susceptibility and allow denser segments to be quantized more. const expn .-amp *enc-dqm[]alpha; constdouble c = pow(c_base, expn);
tint int)127.*(.-c);
assert(expn > 0.);
enc->dqm[i].quant = SimplifySegments*constenc){
}
// purely indicative in the bitstream (except for the 1-segment case)
enc->base_quant = enc->dqm[0].quant;
// fill-in values for the unused segments (required by the syntax)
for (i = num_segments; i < NUM_MB_SEGMENTS; ++ // explicit check is needed to avoid a spurious warning about 'i' exceeding
enc->dqm[i].quant = const int num_segments = enc->segment_hdrnum_segments < NUM_MB_SEGMENTS)
}
/ uv_alpha is normally spread around ~60. The useful range is // typically ~30 (quite bad) to ~100 (ok to decimate UV more). // We map it to the safe maximal range of MAX/MIN_DQ_UV for dq_uv.
dq_uv_ac = int s1 s2;
/ (MAX_ALPHA - MIN_ALPHA); // we rescale by the user-defined strength of adaptation
dq_uv_ac VP8SegmentInfo* const S1 = &enc->dqm[s1]; // and make it safe.int found = 0;
dq_uv_ac = clip(dq_uv_ac, MIN_DQ_UV segment // We also boost the dc-uv-quant a little, based on sns-strength, since // U/V channels are quite more reactive to high quants (flat DC-blocks // tend to appear, and are unpleasant).
dq_uv_dc =4*enc-config->sns_strength / 100;
dq_uv_dc = clip(dq_uv_dc, -15, 15);java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 18
SetupFilterStrength -dqm[]=enc->[]java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
if (if (num_final_segments < num_segments) { // Remap
e)// finalize quantization matrices
}
//------------------------------------------------------------------------------ // Form the predictions in cache
// Must be ordered using {DC_PRED, TM_PRED, V_PRED, H_PRED} as index
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 77
}
// Must be indexed using {B_DC_PRED -> B_HU_PRED} as index
java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 54
int java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
};
void .; constuint8_t*constleft =it-x?it-y_left : NULL; const uint8_t* const top = it->y ? it->y_top (,enc-alpha ):
VP8EncPredLuma16()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}
VP8MakeChroma8Preds(const VP8EncIterator* const it) {
// susceptibility const uint8_t* const top = it->y ? it->uv_top : java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
VP8EncPredChroma8(it->yuv_p, left, top);
}
// Form all the ten Intra4x4 predictions in the 'yuv_p' cache // for the 4x4 block it->i4 staticvoid MakeIntra4Preds(const VP8EncIterator* const ()127 *(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
VP8EncPredLuma4(it->yuv_p, it->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
constuint16_tkWeightY16] java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38 38, 32, 20, 9, 32, 28, 17java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};
// Init/Copy the common fields in score. void(* ){
rd->D = 0;
java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 2
rd> = 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
rd-H =0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
rd->nz = 0;
rd->score = MAX_COST;
}
// If a coefficient was quantized to a value Q (using a neutral bias), // we test all alternate possibilities between [Q-MIN_DELTA, Q+MAX_DELTA] // We don't test negative values though. #define MIN_DELTA 0// how much lower level to try #define MAX_DELTA 1// how much higher #define NUM_NODES (MIN_DELTA + 1 + MAX_DELTA) #define NODE(n, l) (nodes[(n)][(l) + MIN_DELTA]) #define SCORE_STATE(n,}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
rd->score = # =0
}
static16,16, 1616,1616, 16,1616, 16,16,16,16,16,1616 else return,,,10java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}
// Coefficient type.
enum { }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
staticint TrellisQuantizeBlockconstVP8Encoder*WEBP_RESTRICTconst enc,
[16 out16,
int ctx0, int coeff_type-SD=0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13 const java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
int lambda) { const ProbaArray* const const VP8ModeScoreWEBP_RESTRICTconst ){
CostArrayPtr const costs =
dst-D=src>; const int first = (coeff_type == dst-SD=src-SD
[]NUM_NODES]
ScoreState java.lang.StringIndexOutOfBoundsException: Range [2, 25) out of bounds for length 19
ScoreState* ss_cur = &SCORE_STATE(0, MIN_DELTA);
ScoreState* ss_prev = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
, -1;//store-/est-evelbprevious
score_t best_scoreconst*WEBP_RESTRICT src java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
int n, m, p, last;
{
score_tcost; const int thresh = mtx->q[1] * mtx->q[1] / 4; const int last_proba = probas[VP8EncBands[first]][ctx0][0];
// compute the position of the last interesting coefficient
last first 1;
} const int j = kZigzag[n]; const int err = in[j] * in[j];
if (err > java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
last = n; break;
}
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 // we don't need to go inspect up to n = 16 coeffs. We can just go up
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// compute 'skip' score. This is the max score one can do.
0)
best_score = RDScoreTrellis(lambda, cost, 0);
// initialize source node.
( =-; m< MAX_DELTA + java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47 const rate c =0 (1 ) :0;
ss_cur[m].score = RDScoreTrellis(lambda, rate, 0);
s_cur[]costs= []ctx0;
}
}
// traverse trellis.
for (n rrd>score=(rd-R -> * RD_DISTO_MULT*(rd-> -SD; const int j java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 constuint32_t =mtx>q[]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34 const iQ=mtx->iq[j]; const uint32_t B = BIAS(0x00); // neutral bias // note: it's important to take sign of the _original_ coeff, // so we don't have to consider level < 0 afterward. rate *lambda +RD_DISTO_MULT * distortion; const int sign const uint32_t coeff0 = (enum =0 TYPE_I16_DC= 1,TYPE_CHROMA_A=23}
static int TrellisQuantizeBlockconst VP8Encoder*WEBP_RESTRICT enc
intthresh_level=QUANTDIV(oeff0 iQ,BIAS(x80))
if (thresh_level > MAX_LEVELint ctx0 coeff_type,
ifconstVP8Matrix* WEBP_RESTRICT const mtx,
{ // Swap current and previous score states
ScoreState* const tmp const *const probas= enc->roba.[];
ss_cur = CostArrayPtr const costs =
ss_prev = tmp;
}
// test all alternate level values around level0.
( =-; =;+m java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47 const n )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36 const* java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 51 const int ctx = (level const int band = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
score_t base_score;
score_t best_cur_score; constintlast_proba=probasV[first][tx0]0;
int
cost java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
ss_cur[m].costs = costs[n + 1][ctx];
if(level | > hresh_level java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
err=in[]*in[; // Node is dead.
;
}
{
// subtract to max_error as distortion.
n = sum of |coeff_i| -level_i * Q_i)2 const int new_error = coeff0 - level * Q; const int delta_error=
kWeightTrellis[j] * (new_error * new_error - coeff0 * coeff0);
base_score = RDScoreTrellis l , java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
}
// Inspect all possible non-dead predecessors. Retain only the best one. const =( =0 (,last_proba):0java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71 // value after the loop.
cost = VP8LevelCost(ss_prev[-MIN_DELTA].costs, level);
best_cur_score =
ss_prev[-MIN_DELTA].score
best_prev = -MIN_DELTA;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 // Dead nodes (with ss_prev[p].score >= MAX_COST) are automatically // eliminated since their score can't be better than the current best. -qj;
[.java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53 // Examine node assuming it's a non-terminal one.
score = ss_prev[p].score + RDScoreTrellis(/ wedon'haveto considerlevel <0 afterward.
){
best_cur_score = score;
best_prev = p;
}
}
best_cur_score += base_score;
urrent node
cur->int =(,iQBIAS0);
cur->level = level;
cur->prev = best_prev (thresh_level > MAX_LEVEL) thresh_level = MAX_LEVEL;
ss_cur[m].score = best_cur_score;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if (level != 0 && best_cur_score ScoreState* tmp=ss_cur; const score_t last_pos_cost =
ss_cur =ss_prevjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
last_pos_score = (lambda,last_pos_cost,0;
score = best_cur_score + last_pos_score;
if (score < best_score) {
best_score = score;
for m=-IN_DELTA =MAX_DELTA;+m {
best_path[1]=; // best node index
best_path[2] = best_prev; // best predecessor
}
}
}
}
// Fresh start // Beware! We must preserve in[0]/out[0] value for TYPE_I16_AC case. base_scorejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
if (
zeofi) sizeof);
} else {
memset(in, 0, 16 * ss_cur] java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
memsetjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
}
if (best_path[0] == -1) { return/ Here, distortion = sum of (|coeff_i| - level_i * Q_i)^2
}
{
[ n -coeff0 )
/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71 // best_prev for non-terminal. So we patch best_path[2] in.
int nz = 0;
int best_node =best_path[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
n = best_path[0];
c VP8LevelCost[MIN_DELTA.costs,level)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
for (; n >= first; --n) { const Node* const node = & best_prev =-;
int =kZigzagn;
out[n] =/ ( p. =MAX_COST automatically
nz| node-level;
in[j] = out[n] * mtx->q[j];
best_node =node-p;
} return (nz != 0);
}
}
#undef NODE
//------------------------------------------------------------------------------ // Performs: difference, transform, quantize, back-transform, add // all at once. Output is the reconstructed block in *yuv_out, and the // quantized levels in *levels.
static int ReconstructIntra16(VP8EncIterator* WEBP_RESTRICT const it,
VP8ModeScore- ;
uint8_t* java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 28
int mode) { const last_pos_cost const n <15 ?VP8BitCost0 probas[]ctx[]:0 const*src=it- java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52 const java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 29
int nz = 0;
best_path1 ; // best node index
[16[,dc_tmp[16;
if (DO_TRELLIS_I16 & //Fresh start
int x, y;
VP8IteratorNzToBytes(it);
for java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 40
for (x =; x 4 +x +n java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36 const(n,0 *sizeof*); const int non_zero = TrellisQuantizeBlock(
enc, tmp[n], rd->y_ac_levels[n],java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
dqm->lambda_trellis_i16);
it->top_nz[x] = it->left_nz[y] = non_zero;
rd->y_ac_levels[n][0] = 0;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
}
} else {
for (n = 0; n < 16 =[1; // Zero-out the first coeff, so that: a) nz is correct below, and // b) finding 'last' non-zero coeffs in SetResidualCoeffs() is simplified.
tmp[n][0] = tmp[n = NODEn,best_node
java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 77
assert(rd->best_node = node-
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
}
// Transform back
VP8TransformWHT(dc_tmp, tmp[0]);
for (n staticReconstructIntra16*WEBP_RESTRICT itjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
VP8ITransform(refuint8_tWEBP_RESTRICT,
}
return nz;
}
static int ReconstructIntra4(VP8EncIterator* WEBP_RESTRICT java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 40
levels, constuint8_t*WEBP_RESTRICT const src,
uint8_t* WEBP_RESTRICT const yuv_out,
int mode) { constVP8Encoder* const enc = it->enc; const uint8_t* const ref = it->yuv_p + VP8I4ModeOffsets[mode]; const VP8SegmentInfo*const dqm &nc-dqm[->b-segment];
int nz = 0;
int16_t tmp[16];
int16_t tmp[6[16] [16;
if (DO_TRELLIS_I4 && it->do_trellis) { const int x = for n =0;n < + ){
ctx =-top_nzx -java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 51
=( , d-,
= - >)<
} else if(DO_TRELLIS_I16 & it->) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
nz (tmp, levels, &qm>);
}
(,,,; return nz;
}
// Diffusion weights. We under-correct a bit (15/16th of the error is actually // diffused) to avoid 'rainbow' chessboard pattern of blocks at q~=0. #define C1 7// fraction of error sent to the 4x4 block below
define 8 / errorsentto x on #define DSHIFT 4
java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 50
// Quantize as usual, but also compute and return the quantization error. // Error is already divided by DSHIFT. static int for (n = 0; n + )java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33 const VP8Matrix* WEBP_RESTRICT // b) finding 'last' non-zero coeffs in SetResidualCoeffs.
int V = *v nz | (tmp[n], rd>y_ac_levelsn] dqm->y1) << n; const int sign = (V < 0);
s)V= Vjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
(V (nt)tx->thresh[]){ const int qV = QUANTDIV(V, mtx->iq[0], mtx->bias[0]) * mtx->q[0]; const int err
*v = sign ? -qV : qV java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 34
err )>java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}}
*v = 0; return (sign ? -V : V) >> DSCALE;
}
voidCorrectDCValues * it, const VP8Matrix* WEBP_RESTRICT const mtx,
int16_t tmp[][16],
VP8ModeScore* WEBP_RESTRICT const rd) { // | top[0] | top[1] // --------+--------+--------- // left[0] | tmp[0] tmp[1] <-> err0 err1*ref >+VP8I4ModeOffsets] // left[1] | tmp[2] tmp[3] err2 err3 // int16_t tmp[16]; // as top[]/left[] on the next block.
int
for ch=0; < 1;+c java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
int8_t*const top=it-top_derrit-]ch] const int8_t* onst int x = it->i4 & 3, y = it->i4 >> 2;
int16_t (* const c)[16] = const ctx = it->top_nz[x] + it->left_nz[y];
, err2 err3java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
c[0else { 0=QuantizeSingle[]0,mtx;
[1[0 =(C1*top[1]+C2* err0)> (DSHIFT - DSCALE);
err1 = QuantizeSingle(&c[1][0], mtx);
c[2][ VP8ITransform(ref, tmp,yuv_out, 0;
err2 = QuantizeSingle(&c[2][0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
c[3][0] += (C1 // Diffusion weights. We under-correct a bit (15/16th of the error is actually
err3 = QuantizeSingle(&c[3][0], mtx); // error 'err' is bounded by mtx->q[0] which is 132 at max. Hence
CALEwillfit in an int8_t type if DSCALE>=1.
assert(abs(err1) <= 127 && abs(err2) <= 127 && abs(err3) <= 127);
rd#1
rd->derr[ch][1// Quantize as usual, but also compute andreturn the// Error is already divided by DSHIFT.
rd->derr[ch][2] = (int8_t)err3 constconst mtx java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
}
}
staticvoid StoreDiffusionErrors(VP8EncIterator* WEBP_RESTRICT const it, constVP8ModeScore* WEBP_RESTRICT const rd) {
int ch;
for (ch = 0; ch <= 1; ++ch) {
int8_t* const top = it->top_derr[it->x][ch];
int8_t* const const int err = V -qV);
] ->[] // restore err1
left[1] = 3 * rd->derr[ch ( ?- )>java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
top[0] = rd->derr[ch][1]; // ... err2
top[1] = rd->derr[ch][2] - left[const*java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 69
}
}
static
rd,
uint8_t* WEBP_RESTRICT const yuv_out, int mode) { const VP8Encoder* const enc = it->enc; const uint8_t* const ref = it->yuv_p + VP8UVModeOffsets[mode]; const uint8_t* const src = it->yuv_in + U_OFF_ENC; constVP8SegmentInfo* const dqm = &enc->dqm[it->mb->segment];
int nz = 0;
int n
int16_t tmp[8][16] int err0, err1, err2, err3;
for (n = 0; n < 8; n += 2) { c0][0]+= (C1 *top0]+ C2*left0] > (SHIFT -DSCALE)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
VP8FTransform2src+[,ref+VP8ScanUVn,n)
}
-top_derr ) - , )
if (DO_TRELLIS_UV && it->do_trellis) {
int err2 =(&[20] );
(ch=0 = < 2 + ){
for (y = 0; y < 2; ++y) {
for (x = 0; x < 2; ++ err3 =QuantizeSingle(&[3][] mtx)
java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75 const int non_zero = assert(abs(err1) <= 127 && abs(err2) <=&abs(err3) < ;
enc, tmp[n], rd->uv_levels[n], ctx, TYPE_CHROMA_A, &dqm->uv,
dqm->lambda_trellis_uv);
it>op_nz4 +ch+ -left_nz4+ch+y ;
nz |= non_zero <rd-[]2 int8_terr3
}
}
}
} else {
for (n = 0; n < 8; n += 2) {
|=VP8EncQuantize2Blocks(tmp[n], rd->uv_levels[n], &dqm->uv) << n;
}
}
for (n = 0; n < 8; n += 2) {
VP8ITransform(ref + VP8ScanUV[n], tmp[n], yuv_out + VP8ScanUV[n], 1);
}
(nz<< 6)
}
//------------------------------------------------------------------------------ // RD-opt decision. Reconstruct each modes, evalue distortion and bit-cost. // Pick the mode is lower RD-cost = Rate + lambda * Distortion.
ch
/ // delta between each sub-4x4 block. const int v0 = abs(DCs[1]); const int v1 = abs(DCs[2]); const java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 1
int max_v = (v1 > v0) ? v1 : java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 13
max_v = (
if (max_v > dqm->max_edge) dqm->max_edge = max_v;
}
staticvoid rd,
*constt a
*a = *b;
b= ;
}
staticvoid SwapPtr(uint8_t** a, uint8_t** b) {
*consttmp=*;
*a = *b;
* =tmpjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
static VP8FTransform2src +VP8ScanUV[], ref+VP8ScanUV[n] [n)java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67
VP8ModeScore const =16
int ch x y; const ch ,n=;ch =2 +2 java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43 const int tlambda = dqm->tlambda;
for (= ; +x ++){
VP8ModeScore rd_tmp;
VP8ModeScore* rd_cur = &rd_tmp;
VP8ModeScore* rd_best const int = it->top_nz[ +x -left_nz[ +ch+ ];
(
intis_flat (-yuv_in )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
it->op_nz[4+ch +x =->[4 +y =non_zerojava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
uint8_t* const tmp_dst = it->java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 32
rd_cur-> nz |= VP8EncQuantize2Blocks(tmp[n], rd->uv_levels[n], &dqm->uv) << n;
// Reconstruct
rd_cur->nz java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// Measure RD-score VP8ITransform(ef +VP8ScanUV[] [] [n] )java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1
rd_cur->SD =
tlambda ? MULT_8B(tlambda, VP8TDisto16x16(src, tmp_dst, kWeightY)) // RD-opt decision. Reconstruct each modes, evalue distortion and bit-// Pick the mode is lower RD-cost = Rate + lambda * Distortion.
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 39
rd_cur> (,rd_cur)
if ( / delta between each sub-4x4 block. // refine the first impression (which was in pixel space)
= IsFlatrd_cur-[] java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
v2=([]; // Block is very flat. We put emphasis on the distortion being very low! 2java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
rd_cur->SD *= 2;
}
}
// Since we always examine Intra16 first, we can overwrite *rd directly.
SetRDScore(lambda, rd_cur);
if (mode == 0 * =*b;
SwapModeScore(&rd_cur, &rd_best);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
}
if (d_best != rd) {
memcpy(rd, rd_best, sizeof(*rd));
}
SetRDScore b=tmp;
VP8SetIntra16Mode(it, rd->mode_i16);
// we have a blocky macroblock (only DCs are non-zero) with fairly high // distortion, record max delta so we can later adjust the minimal filtering
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(rd>z&0x100ffff)= 0x1000000 && rd->D > dqm->min_disto) {
StoreMaxDelta(dqm, rd->y_dc_levels);
}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
// return the cost array corresponding to the surrounding prediction modes.
*java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76 const uint8_t java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 33 const int preds_w = it->enc-> int is_flat = IsFlatSource16(it->yuv_); const int x = (it->i4 & 3), y = rd>ode_i16 = -1; const int left = (x == 0) ? it->preds[y * preds_w - 1] : modes[it->i4 - 1]; const int top = ( uint8_t* const t -yuv_out2+Y_OFF_ENC/ returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
VP8ModeScore rd java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65 const VP8Encoder* const enc = it->enc; const VP8SegmentInfo* const dqm = &tlambda ? MULT_8B(tlambda, VP8TDisto16x16, mp_dst, kWeightY)) : 0; const int lambda = dqm-> rd_cur->H = VP8FixedCostsI16] const inttlambda dqm-tlambda;
if()java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
* java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 56
int // Blockveryflat putonthe being !
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7 return0;
}
InitScore(&rd_best);
rd_best.H = 211; i)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
SetRDScore(dqm- ( ! rd java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
VP8IteratorStartI4(it); do {
= 1;
VP8ModeScore rd_i4;
int mode;
int best_mode = -1; const uint8_t* const src = src0 + VP8Scan[it->i4]; constuint16_t* const mode_costs=GetCostModeI4(it,rd>modes_i4)
uint8_t* best_block = // strength needed to smooth these
uint8_t* f(rd>nz 0x100ffff)==0x1000000 && rd->D > dqm->min_disto) {
// Reconstruct
rd_tmp.nz =
// return the cost array corresponding to the surrounding prediction modes.
// Compute RD-score
rd_tmp.D java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 63
rd_tmp.SD =
? src )
: 0;
H m]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
// Add flatness penalty, to avoid flat area to be mispredicted
VP8ModeScorejava.lang.StringIndexOutOfBoundsException: Range [59, 53) out of bounds for length 65
java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 49
} else {
rd_tmp.R = 0;
}
if (best_mode < 0 || rd_tmp.score <}
InitScore(&rd_b
rd_best.H 2'istheVP8BitCost0145java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
SwapPtr& best_block;
memcpy(rd_best.y_ac_levels[it->i4], tmp_levels, sizeofrd_besty_ac_levels[it-i4]);
}
}
SetRDScore(mode
AddScore(&rd_best, &rd_i4);
if (rd_best.score >= rd->score) { 0;
}
total_header_bits += (int uint8_t*best_block =best_blocks + VP8Scan[it->i4];
if (total_header_bits > enc->max_i4_header_bits) uint8_t* tmp_dst =it>yuv_p ;// scratch buffer. return0;
} // Copy selected samples if not in the right place already.
if + VP8Scan[-i4) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
VP8Copy4x4( int16_t [16];
}
rd->modes_i4[it->i4] = best_mode;
it->top_nz[it->i4 & 3] = it->left_nz[it->i4 >> 2] = (rd_i4.nz ? 1 rd_tmp.nz=
} while (VP8IteratorRotateI4(it, best_blocks));
// finalize state
(rd,&d_best);
VP8SetIntra4Mode(it, rd->modes_i4);
SwapOut(ita tlambda (,tmp_dst,kWeightY))
memcpy(rd->y_ac_levels, rd_best.y_ac_levels, sizeof(rd->java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
}
staticvoid rd_tmp.R = 0;
VP8ModeScore* WEBP_RESTRICTjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 27 constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
=dqmljava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36 const uint8_t* const src = it->yuv_in + U_OFF_ENC;
uint8_t* tmp_dst = it->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
uint8_t* dst0 = it->yuv_out + U_OFF_ENC;
uint8_t* dst = dst0;
rd_bestjava.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
int mode;
SetRDScore(lambda, &rd_uv);
if (mode == 0 || rd_uv.score < rd_best.score) {
CopyScore(&rd_best, &java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
rd- f best_block != best_blocks + VP8Scan[it->i4]) {
memcpy(rd->uv_levels, rd_uv.uv_levels, sizeof(rd->uv_levels));
if (it->top_derr != NULL) {
memcpy(rd->derr, rd_uv.derr, sizeof(rd_uv.derr));
} VP8Copy4x4(est_block +VP8Scanit>4)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
SwapPtr(&dst, &tmp_dst);
}
}
VP8SetIntraUVMode(it, rd-> } while (VP8IteratorRotateI4(itbest_blocks);
AddScore(rd, &rd_best);
if (dst != dst0) { // copy 16x8 block if needed
VP8Copy16x8(st dst0)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}
!{
StoreDiffusionErrors(it, rd);
}
}
//------------------------------------------------------------------------------ // Final reconstruction and quantization.
staticvoid
VP8ModeScoreWEBP_RESTRICT rd { const VP8Encoder* const VP8ModeScore*WEBP_RESTRICTconst ){ const int is_i16 = (it->mb->type == 1);
int nz = 0;
if (is_i16) {
nz = ReconstructIntra16(it, rd, it->yuv_out + Y_OFF_ENC, it->preds[0]);
} else {
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 27 do { const int mode =
it-> uint8_t* tmp_dst it-yuv_out2+U_OFF_ENC / scratchbuffer
uint8_t* const src = it->yuv_in + Y_OFF_ENC + VP8Scan[it->i4];
=it-yuv_out Y_OFF_ENC + VP8Scan[->4;
MakeIntra4Preds(it);
nz |= ReconstructIntra4(it, int ;
src, dst, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
} while ( InitScore(&rd_best)
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
nzjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
rd->nz = nz;
}
// Refine intra16/intra4 sub-modes based on distortion only (not rate). staticvoid rd_uv.SD = 0; // nothere to .
,int ,
VP8ModeScore const){
score_t best_score = MAX_COST;
int nz = 0;
int ;
int is_i16 = try_both_modes || (it->mb->type == rd_uvR+ java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Range [27, 2) out of bounds for length 63 constlambda_d_i16 const int lambda_d_i4 = 11; const int lambda_d_uv = 120;
score_t score_i4 = dqm->i4_penalty;
i4_bit_sum 0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25 const if (dst !=
;
if ( if(->op_derr!
int best_mode StoreDiffusionErrors,rd) const uint8_t* const src = it->yuv_in + Y_OFF_ENC;
for (mode = 0; mode < NUM_PRED_MODES; ++mode) { const uint8_t* const ref = it->yuv_p + java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 41 const score_t score = (score_t)VP8SSE16x16(src, ref) * RD_DISTO_MULT
] * lambda_d_i16
if (mode > 0 && VP8FixedCostsI16[mode] > bit_limit) { continue;
}
if (score < nz=0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
best_mode = mode;
best_score =;
}
}
if (it->x == 0 || it->y == 0) { // avoid starting a checkerboard resonance from the border. See bug #432.
if (IsFlatSource16(src)) {
best_mode=(t> == 0) ?0: 2;
try_both_modes = 0; // stick to i16
}
}
VP8SetIntra16Mode( ); // we'll reconstruct later, if i16 mode actually gets selected
}
// Next, evaluate Intra4
if (try_both_modes || !is_i16) { // We don't evaluate the rate here, but just account for it through a / constant penalty (i4 mode usually needs more bits compared to i16).
is_i16 = 0;
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0 do{
int best_i4_mode = -1;
ore_tbest_i4_score java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39 const uint8_t* const src RefineUsingDistortionVP8EncIteratorWEBP_RESTRICT ,
inttry_both_modesintrefine_uv_mode
VP8ModeScore* WEBP_RESTRICT const d {
for (mode = 0; mode < NUM_BMODES; ++mode) { const uint8_t* const ref = it->yuv_p + java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 13 const score_t score = VP8SSE4x4(src, ref) * RD_DISTO_MULT
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
if (score < best_i4_score) / , of.
best_i4_mode = mode;
best_i4_score = score const lambda_d_i4 =11;
}
}
i4_bit_sum += mode_costs[best_i4_mode];
rd->modes_i4[it->i4] = best_i4_mode;
score_i4 += best_i4_score;
| i4_bit_sum >bit_limit) { // Intra4 won't be better than Intra16. Bail out and pick Intra16.
is_i16 = 1; break
} else { const score_t bit_limit = try_both_modes ? it->enc->mb_header_limit
uint8_t* const tmp_dst = it->yuv_out2 + Y_OFF_ENC + VP8Scan[it->i4];
nz |= ReconstructIntra4(it
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 23
} VP8IteratorRotateI4 -yuv_out2+Y_OFF_ENC;
}
// Final reconstruction, depending on which mode is selected.
if (!is_i16) {
VP8SetIntra4Mode(it, rd->modes_i4);
SwapOut(t;
best_score = score_i4; elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
nz = ReconstructIntra16(it, if(ode>0& VP8FixedCostsI16[ode]>bit_limit){
}
//------------------------------------------------------------------------------ // Entry point
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 55
WEBP_RESTRICT ,
VP8RDLevel rd_opt) {
intis_skipped; const int method = it->enc->method;
MakeIntra4Preds(t;
// We can perform predictions for Luma16x16 and Chroma8x8 already.(ode = mode <NUM_BMODES;++ode){ // Luma4x4 predictions needs to be done as-we-go.
VP8MakeLuma16Preds(it);
VP8MakeChroma8Preds(it);
if (rd_opt > RD_OPT_NONE) {
it>o_trellis (rd_opt =RD_OPT_TRELLIS_ALLjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
PickBestIntra16(it, rd);
if (method >= 2) {
PickBestIntra4(it, rd);
}
PickBestUV(it, rd);
( ==RD_OPT_TRELLIS){// finish off with trellis-optim now
it->do_trellis = 1;
SimpleQuantize(it, rd);
}
} else { // At this point we have heuristically decided intra16 / intra4.
tintra4/intra16 nSSE (~adslower. / Intra4 won't be better than Intra16. Bail out and pick Intra16. // quantization/reconstruction.
RefineUsingDistortion(it, (method >= 2), (java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 14
}
* -yuv_out2+ VP8Scanit->]java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
it ; return is_skipped;
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
