| |
| |
| #### 15.3 Normal Filter {#h-15-03} |
| |
| |
| The normal loop filter is a refinement of the simple loop filter; all |
| of the general discussion above applies here as well. In particular, |
| the functions `c`, `u2s`, `s2u`, `abs`, and `common_adjust` are used by both |
| the normal and simple filters. |
| |
| As mentioned above, the normal algorithms for inter-macroblock and |
| inter-subblock edges differ. Nonetheless, they have a great deal in |
| common: They use similar threshold algorithms to disable the filter |
| and to detect high internal edge variance (which influences the |
| filtering algorithm). Both algorithms also use, at least |
| conditionally, the simple filter adjustment procedure described |
| above. |
| |
| The common thresholding algorithms are as follows. |
| |
| |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| /* All functions take (among other things) a segment (of length |
| at most 4 + 4 = 8) symmetrically straddling an edge. |
| |
| The pixel values (or pointers) are always given in order, |
| from the "beforemost" to the "aftermost". So, for a |
| horizontal edge (written "|"), an 8-pixel segment would be |
| ordered p3 p2 p1 p0 | q0 q1 q2 q3. */ |
| |
| /* Filtering is disabled if the difference between any two |
| adjacent "interior" pixels in the 8-pixel segment exceeds |
| the relevant threshold (I). A more complex thresholding |
| calculation is done for the group of four pixels that |
| straddle the edge, in line with the calculation in |
| simple_segment() above. */ |
| |
| int filter_yes( |
| uint8 I, /* limit on interior differences */ |
| uint8 E, /* limit at the edge */ |
| |
| cint8 p3, cint8 p2, cint8 p1, cint8 p0, /* pixels before |
| edge */ |
| cint8 q0, cint8 q1, cint8 q2, cint8 q3 /* pixels after |
| edge */ |
| ) { |
| return (abs(p0 - q0)*2 + abs(p1 - q1)/2) <= E |
| && abs(p3 - p2) <= I && abs(p2 - p1) <= I && |
| abs(p1 - p0) <= I |
| && abs(q3 - q2) <= I && abs(q2 - q1) <= I && |
| abs(q1 - q0) <= I; |
| } |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| {:lang="c"} |
| |
| |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| /* Filtering is altered if (at least) one of the differences |
| on either side of the edge exceeds a threshold (we have |
| "high edge variance"). */ |
| |
| int hev( |
| uint8 threshold, |
| cint8 p1, cint8 p0, /* pixels before edge */ |
| cint8 q0, cint8 q1 /* pixels after edge */ |
| ) { |
| return abs(p1 - p0) > threshold || abs(q1 - q0) > threshold; |
| } |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| {:lang="c"} |
| |
| The subblock filter is a variant of the simple filter. In fact, if |
| we have high edge variance, the adjustment is exactly as for the |
| simple filter. Otherwise, the simple adjustment (without outer taps) |
| is applied, and the two pixels one step in from the edge pixels are |
| adjusted by roughly half the amount by which the two edge pixels are |
| adjusted; since the edge adjustment here is essentially 3/8 the edge |
| difference, the inner adjustment is approximately 3/16 the edge |
| difference. |
| |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| void subblock_filter( |
| uint8 hev_threshold, /* detect high edge variance */ |
| uint8 interior_limit, /* possibly disable filter */ |
| uint8 edge_limit, |
| cint8 *P3, cint8 *P2, int8 *P1, int8 *P0, /* pixels before |
| edge */ |
| int8 *Q0, int8 *Q1, cint8 *Q2, cint8 *Q3 /* pixels after |
| edge */ |
| ) { |
| cint8 p3 = u2s(*P3), p2 = u2s(*P2), p1 = u2s(*P1), |
| p0 = u2s(*P0); |
| cint8 q0 = u2s(*Q0), q1 = u2s(*Q1), q2 = u2s(*Q2), |
| q3 = u2s(*Q3); |
| |
| if( filter_yes( interior_limit, edge_limit, q3, q2, q1, q0, |
| p0, p1, p2, p3)) |
| { |
| const int hv = hev( hev_threshold, p1, p0, q0, q1); |
| |
| cint8 a = ( common_adjust( hv, P1, P0, Q0, Q1) + 1) >> 1; |
| |
| if( !hv) { |
| *Q1 = s2u( q1 - a); |
| *P1 = s2u( p1 + a); |
| } |
| } |
| } |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| {:lang="c"} |
| |
| The inter-macroblock filter has potentially wider scope. If the edge |
| variance is high, it performs the simple adjustment (using the outer |
| taps, just like the simple filter and the corresponding case of the |
| normal subblock filter). If the edge variance is low, we begin with |
| the same basic filter calculation and apply multiples of it to pixel |
| pairs symmetric about the edge; the magnitude of adjustment decays as |
| we move away from the edge and six of the pixels in the segment are |
| affected. |
| |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| void MBfilter( |
| uint8 hev_threshold, /* detect high edge variance */ |
| uint8 interior_limit, /* possibly disable filter */ |
| uint8 edge_limit, |
| cint8 *P3, int8 *P2, int8 *P1, int8 *P0, /* pixels before |
| edge */ |
| int8 *Q0, int8 *Q1, int8 *Q2, cint8 *Q3 /* pixels after |
| edge */ |
| ) { |
| cint8 p3 = u2s(*P3), p2 = u2s(*P2), p1 = u2s(*P1), |
| p0 = u2s(*P0); |
| cint8 q0 = u2s(*Q0), q1 = u2s(*Q1), q2 = u2s(*Q2), |
| q3 = u2s(*Q3); |
| |
| if( filter_yes( interior_limit, edge_limit, q3, q2, q1, q0, |
| p0, p1, p2, p3)) |
| { |
| if( !hev( hev_threshold, p1, p0, q0, q1)) |
| { |
| /* Same as the initial calculation in "common_adjust", |
| w is something like twice the edge difference */ |
| |
| const int8 w = c( c(p1 - q1) + 3*(q0 - p0) ); |
| |
| /* 9/64 is approximately 9/63 = 1/7, and 1<<7 = 128 = |
| 2*64. So this a, used to adjust the pixels adjacent |
| to the edge, is something like 3/7 the edge |
| difference. */ |
| |
| int8 a = c( (27*w + 63) >> 7); |
| |
| *Q0 = s2u( q0 - a); *P0 = s2u( p0 + a); |
| |
| /* Next two are adjusted by 2/7 the edge difference */ |
| |
| a = c( (18*w + 63) >> 7); |
| |
| *Q1 = s2u( q1 - a); *P1 = s2u( p1 + a); |
| |
| /* Last two are adjusted by 1/7 the edge difference */ |
| |
| a = c( (9*w + 63) >> 7); |
| |
| *Q2 = s2u( q2 - a); *P2 = s2u( p2 + a); |
| |
| } else /* if hev, do simple filter */ |
| common_adjust( 1, P1, P0, Q0, Q1); /* using outer |
| taps */ |
| } |
| } |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| {:lang="c"} |
| |
