diff options
Diffstat (limited to 'vp9')
| -rw-r--r-- | vp9/common/x86/vp9_loopfilter_intrin_sse2.c | 695 | ||||
| -rw-r--r-- | vp9/encoder/vp9_firstpass.c | 271 | ||||
| -rw-r--r-- | vp9/encoder/vp9_firstpass.h | 3 | ||||
| -rw-r--r-- | vp9/encoder/vp9_ratectrl.c | 89 | ||||
| -rw-r--r-- | vp9/encoder/vp9_ratectrl.h | 1 |
5 files changed, 476 insertions, 583 deletions
diff --git a/vp9/common/x86/vp9_loopfilter_intrin_sse2.c b/vp9/common/x86/vp9_loopfilter_intrin_sse2.c index 448ad5af7..de2394b43 100644 --- a/vp9/common/x86/vp9_loopfilter_intrin_sse2.c +++ b/vp9/common/x86/vp9_loopfilter_intrin_sse2.c @@ -12,6 +12,10 @@ #include "vp9/common/vp9_loopfilter.h" #include "vpx_ports/emmintrin_compat.h" +static INLINE __m128i abs_diff(__m128i a, __m128i b) { + return _mm_or_si128(_mm_subs_epu8(a, b), _mm_subs_epu8(b, a)); +} + static void mb_lpf_horizontal_edge_w_sse2_8(unsigned char *s, int p, const unsigned char *_blimit, @@ -46,15 +50,12 @@ static void mb_lpf_horizontal_edge_w_sse2_8(unsigned char *s, { __m128i abs_p1q1, abs_p0q0, abs_q1q0, fe, ff, work; - abs_p1p0 = _mm_or_si128(_mm_subs_epu8(q1p1, q0p0), - _mm_subs_epu8(q0p0, q1p1)); + abs_p1p0 = abs_diff(q1p1, q0p0); abs_q1q0 = _mm_srli_si128(abs_p1p0, 8); fe = _mm_set1_epi8(0xfe); ff = _mm_cmpeq_epi8(abs_p1p0, abs_p1p0); - abs_p0q0 = _mm_or_si128(_mm_subs_epu8(q0p0, p0q0), - _mm_subs_epu8(p0q0, q0p0)); - abs_p1q1 = _mm_or_si128(_mm_subs_epu8(q1p1, p1q1), - _mm_subs_epu8(p1q1, q1p1)); + abs_p0q0 = abs_diff(q0p0, p0q0); + abs_p1q1 = abs_diff(q1p1, p1q1); flat = _mm_max_epu8(abs_p1p0, abs_q1q0); hev = _mm_subs_epu8(flat, thresh); hev = _mm_xor_si128(_mm_cmpeq_epi8(hev, zero), ff); @@ -68,10 +69,8 @@ static void mb_lpf_horizontal_edge_w_sse2_8(unsigned char *s, // mask |= (abs(p1 - p0) > limit) * -1; // mask |= (abs(q1 - q0) > limit) * -1; - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q2p2, q1p1), - _mm_subs_epu8(q1p1, q2p2)), - _mm_or_si128(_mm_subs_epu8(q3p3, q2p2), - _mm_subs_epu8(q2p2, q3p3))); + work = _mm_max_epu8(abs_diff(q2p2, q1p1), + abs_diff(q3p3, q2p2)); mask = _mm_max_epu8(work, mask); mask = _mm_max_epu8(mask, _mm_srli_si128(mask, 8)); mask = _mm_subs_epu8(mask, limit); @@ -125,10 +124,7 @@ static void mb_lpf_horizontal_edge_w_sse2_8(unsigned char *s, { __m128i work; - flat = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q2p2, q0p0), - _mm_subs_epu8(q0p0, q2p2)), - _mm_or_si128(_mm_subs_epu8(q3p3, q0p0), - _mm_subs_epu8(q0p0, q3p3))); + flat = _mm_max_epu8(abs_diff(q2p2, q0p0), abs_diff(q3p3, q0p0)); flat = _mm_max_epu8(abs_p1p0, flat); flat = _mm_max_epu8(flat, _mm_srli_si128(flat, 8)); flat = _mm_subs_epu8(flat, one); @@ -142,21 +138,12 @@ static void mb_lpf_horizontal_edge_w_sse2_8(unsigned char *s, q6p6 = _mm_loadl_epi64((__m128i *)(s - 7 * p)); q6p6 = _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(q6p6), (__m64 *)(s + 6 * p))); - - flat2 = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q4p4, q0p0), - _mm_subs_epu8(q0p0, q4p4)), - _mm_or_si128(_mm_subs_epu8(q5p5, q0p0), - _mm_subs_epu8(q0p0, q5p5))); + flat2 = _mm_max_epu8(abs_diff(q4p4, q0p0), abs_diff(q5p5, q0p0)); q7p7 = _mm_loadl_epi64((__m128i *)(s - 8 * p)); q7p7 = _mm_castps_si128(_mm_loadh_pi(_mm_castsi128_ps(q7p7), (__m64 *)(s + 7 * p))); - - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q6p6, q0p0), - _mm_subs_epu8(q0p0, q6p6)), - _mm_or_si128(_mm_subs_epu8(q7p7, q0p0), - _mm_subs_epu8(q0p0, q7p7))); - + work = _mm_max_epu8(abs_diff(q6p6, q0p0), abs_diff(q7p7, q0p0)); flat2 = _mm_max_epu8(work, flat2); flat2 = _mm_max_epu8(flat2, _mm_srli_si128(flat2, 8)); flat2 = _mm_subs_epu8(flat2, one); @@ -364,20 +351,34 @@ static void mb_lpf_horizontal_edge_w_sse2_8(unsigned char *s, } } +static INLINE __m128i filter_add2_sub2(__m128i total, __m128i a1, __m128i a2, + __m128i s1, __m128i s2) { + total = _mm_add_epi16(a1, total); + total = _mm_add_epi16(_mm_sub_epi16(total, _mm_add_epi16(s1, s2)), a2); + return total; +} + +static INLINE __m128i filter8_mask(__m128i flat, __m128i other_filt, + __m128i f8_lo, __m128i f8_hi) { + const __m128i f8 = _mm_packus_epi16(_mm_srli_epi16(f8_lo, 3), + _mm_srli_epi16(f8_hi, 3)); + const __m128i result = _mm_and_si128(flat, f8); + return _mm_or_si128(_mm_andnot_si128(flat, other_filt), result); +} + +static INLINE __m128i filter16_mask(__m128i flat, __m128i other_filt, + __m128i f_lo, __m128i f_hi) { + const __m128i f = _mm_packus_epi16(_mm_srli_epi16(f_lo, 4), + _mm_srli_epi16(f_hi, 4)); + const __m128i result = _mm_and_si128(flat, f); + return _mm_or_si128(_mm_andnot_si128(flat, other_filt), result); +} + static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, int p, const unsigned char *_blimit, const unsigned char *_limit, const unsigned char *_thresh) { - DECLARE_ALIGNED_ARRAY(16, unsigned char, flat2_op, 7 * 16); - DECLARE_ALIGNED_ARRAY(16, unsigned char, flat2_oq, 7 * 16); - - DECLARE_ALIGNED_ARRAY(16, unsigned char, flat_op, 3 * 16); - DECLARE_ALIGNED_ARRAY(16, unsigned char, flat_oq, 3 * 16); - - DECLARE_ALIGNED_ARRAY(16, unsigned char, ap, 8 * 16); - DECLARE_ALIGNED_ARRAY(16, unsigned char, aq, 8 * 16); - const __m128i zero = _mm_set1_epi16(0); const __m128i one = _mm_set1_epi8(1); const __m128i blimit = _mm_load_si128((const __m128i *)_blimit); @@ -387,8 +388,14 @@ static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, __m128i p7, p6, p5; __m128i p4, p3, p2, p1, p0, q0, q1, q2, q3, q4; __m128i q5, q6, q7; - int i = 0; + __m128i op2, op1, op0, oq0, oq1, oq2; + + __m128i max_abs_p1p0q1q0; + + p7 = _mm_loadu_si128((__m128i *)(s - 8 * p)); + p6 = _mm_loadu_si128((__m128i *)(s - 7 * p)); + p5 = _mm_loadu_si128((__m128i *)(s - 6 * p)); p4 = _mm_loadu_si128((__m128i *)(s - 5 * p)); p3 = _mm_loadu_si128((__m128i *)(s - 4 * p)); p2 = _mm_loadu_si128((__m128i *)(s - 3 * p)); @@ -399,58 +406,59 @@ static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, q2 = _mm_loadu_si128((__m128i *)(s + 2 * p)); q3 = _mm_loadu_si128((__m128i *)(s + 3 * p)); q4 = _mm_loadu_si128((__m128i *)(s + 4 * p)); - - _mm_store_si128((__m128i *)&ap[4 * 16], p4); - _mm_store_si128((__m128i *)&ap[3 * 16], p3); - _mm_store_si128((__m128i *)&ap[2 * 16], p2); - _mm_store_si128((__m128i *)&ap[1 * 16], p1); - _mm_store_si128((__m128i *)&ap[0 * 16], p0); - _mm_store_si128((__m128i *)&aq[4 * 16], q4); - _mm_store_si128((__m128i *)&aq[3 * 16], q3); - _mm_store_si128((__m128i *)&aq[2 * 16], q2); - _mm_store_si128((__m128i *)&aq[1 * 16], q1); - _mm_store_si128((__m128i *)&aq[0 * 16], q0); - + q5 = _mm_loadu_si128((__m128i *)(s + 5 * p)); + q6 = _mm_loadu_si128((__m128i *)(s + 6 * p)); + q7 = _mm_loadu_si128((__m128i *)(s + 7 * p)); { - const __m128i abs_p1p0 = _mm_or_si128(_mm_subs_epu8(p1, p0), - _mm_subs_epu8(p0, p1)); - const __m128i abs_q1q0 = _mm_or_si128(_mm_subs_epu8(q1, q0), - _mm_subs_epu8(q0, q1)); + const __m128i abs_p1p0 = abs_diff(p1, p0); + const __m128i abs_q1q0 = abs_diff(q1, q0); const __m128i fe = _mm_set1_epi8(0xfe); - const __m128i ff = _mm_cmpeq_epi8(abs_p1p0, abs_p1p0); - __m128i abs_p0q0 = _mm_or_si128(_mm_subs_epu8(p0, q0), - _mm_subs_epu8(q0, p0)); - __m128i abs_p1q1 = _mm_or_si128(_mm_subs_epu8(p1, q1), - _mm_subs_epu8(q1, p1)); + const __m128i ff = _mm_cmpeq_epi8(zero, zero); + __m128i abs_p0q0 = abs_diff(p0, q0); + __m128i abs_p1q1 = abs_diff(p1, q1); __m128i work; - flat = _mm_max_epu8(abs_p1p0, abs_q1q0); - hev = _mm_subs_epu8(flat, thresh); - hev = _mm_xor_si128(_mm_cmpeq_epi8(hev, zero), ff); + max_abs_p1p0q1q0 = _mm_max_epu8(abs_p1p0, abs_q1q0); abs_p0q0 =_mm_adds_epu8(abs_p0q0, abs_p0q0); abs_p1q1 = _mm_srli_epi16(_mm_and_si128(abs_p1q1, fe), 1); mask = _mm_subs_epu8(_mm_adds_epu8(abs_p0q0, abs_p1q1), blimit); mask = _mm_xor_si128(_mm_cmpeq_epi8(mask, zero), ff); // mask |= (abs(p0 - q0) * 2 + abs(p1 - q1) / 2 > blimit) * -1; - mask = _mm_max_epu8(flat, mask); + mask = _mm_max_epu8(max_abs_p1p0q1q0, mask); // mask |= (abs(p1 - p0) > limit) * -1; // mask |= (abs(q1 - q0) > limit) * -1; - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p2, p1), - _mm_subs_epu8(p1, p2)), - _mm_or_si128(_mm_subs_epu8(p3, p2), - _mm_subs_epu8(p2, p3))); + work = _mm_max_epu8(abs_diff(p2, p1), abs_diff(p3, p2)); mask = _mm_max_epu8(work, mask); - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q2, q1), - _mm_subs_epu8(q1, q2)), - _mm_or_si128(_mm_subs_epu8(q3, q2), - _mm_subs_epu8(q2, q3))); + work = _mm_max_epu8(abs_diff(q2, q1), abs_diff(q3, q2)); mask = _mm_max_epu8(work, mask); mask = _mm_subs_epu8(mask, limit); mask = _mm_cmpeq_epi8(mask, zero); } - // lp filter + { + __m128i work; + work = _mm_max_epu8(abs_diff(p2, p0), abs_diff(q2, q0)); + flat = _mm_max_epu8(work, max_abs_p1p0q1q0); + work = _mm_max_epu8(abs_diff(p3, p0), abs_diff(q3, q0)); + flat = _mm_max_epu8(work, flat); + work = _mm_max_epu8(abs_diff(p4, p0), abs_diff(q4, q0)); + flat = _mm_subs_epu8(flat, one); + flat = _mm_cmpeq_epi8(flat, zero); + flat = _mm_and_si128(flat, mask); + flat2 = _mm_max_epu8(abs_diff(p5, p0), abs_diff(q5, q0)); + flat2 = _mm_max_epu8(work, flat2); + work = _mm_max_epu8(abs_diff(p6, p0), abs_diff(q6, q0)); + flat2 = _mm_max_epu8(work, flat2); + work = _mm_max_epu8(abs_diff(p7, p0), abs_diff(q7, q0)); + flat2 = _mm_max_epu8(work, flat2); + flat2 = _mm_subs_epu8(flat2, one); + flat2 = _mm_cmpeq_epi8(flat2, zero); + flat2 = _mm_and_si128(flat2, flat); // flat2 & flat & mask + } + + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // filter4 { const __m128i t4 = _mm_set1_epi8(4); const __m128i t3 = _mm_set1_epi8(3); @@ -459,23 +467,27 @@ static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, const __m128i t1f = _mm_set1_epi8(0x1f); const __m128i t1 = _mm_set1_epi8(0x1); const __m128i t7f = _mm_set1_epi8(0x7f); + const __m128i ff = _mm_cmpeq_epi8(t4, t4); - __m128i ps1 = _mm_xor_si128(p1, t80); - __m128i ps0 = _mm_xor_si128(p0, t80); - __m128i qs0 = _mm_xor_si128(q0, t80); - __m128i qs1 = _mm_xor_si128(q1, t80); __m128i filt; __m128i work_a; __m128i filter1, filter2; - filt = _mm_and_si128(_mm_subs_epi8(ps1, qs1), hev); - work_a = _mm_subs_epi8(qs0, ps0); + op1 = _mm_xor_si128(p1, t80); + op0 = _mm_xor_si128(p0, t80); + oq0 = _mm_xor_si128(q0, t80); + oq1 = _mm_xor_si128(q1, t80); + + hev = _mm_subs_epu8(max_abs_p1p0q1q0, thresh); + hev = _mm_xor_si128(_mm_cmpeq_epi8(hev, zero), ff); + filt = _mm_and_si128(_mm_subs_epi8(op1, oq1), hev); + + work_a = _mm_subs_epi8(oq0, op0); filt = _mm_adds_epi8(filt, work_a); filt = _mm_adds_epi8(filt, work_a); filt = _mm_adds_epi8(filt, work_a); // (vp9_filter + 3 * (qs0 - ps0)) & mask filt = _mm_and_si128(filt, mask); - filter1 = _mm_adds_epi8(filt, t4); filter2 = _mm_adds_epi8(filt, t3); @@ -485,7 +497,7 @@ static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, work_a = _mm_and_si128(work_a, te0); filter1 = _mm_and_si128(filter1, t1f); filter1 = _mm_or_si128(filter1, work_a); - qs0 = _mm_xor_si128(_mm_subs_epi8(qs0, filter1), t80); + oq0 = _mm_xor_si128(_mm_subs_epi8(oq0, filter1), t80); // Filter2 >> 3 work_a = _mm_cmpgt_epi8(zero, filter2); @@ -493,7 +505,7 @@ static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, work_a = _mm_and_si128(work_a, te0); filter2 = _mm_and_si128(filter2, t1f); filter2 = _mm_or_si128(filter2, work_a); - ps0 = _mm_xor_si128(_mm_adds_epi8(ps0, filter2), t80); + op0 = _mm_xor_si128(_mm_adds_epi8(op0, filter2), t80); // filt >> 1 filt = _mm_adds_epi8(filter1, t1); @@ -503,345 +515,195 @@ static void mb_lpf_horizontal_edge_w_sse2_16(unsigned char *s, filt = _mm_and_si128(filt, t7f); filt = _mm_or_si128(filt, work_a); filt = _mm_andnot_si128(hev, filt); - ps1 = _mm_xor_si128(_mm_adds_epi8(ps1, filt), t80); - qs1 = _mm_xor_si128(_mm_subs_epi8(qs1, filt), t80); + op1 = _mm_xor_si128(_mm_adds_epi8(op1, filt), t80); + oq1 = _mm_xor_si128(_mm_subs_epi8(oq1, filt), t80); // loopfilter done + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // filter8 { - __m128i work; - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p2, p0), - _mm_subs_epu8(p0, p2)), - _mm_or_si128(_mm_subs_epu8(q2, q0), - _mm_subs_epu8(q0, q2))); - flat = _mm_max_epu8(work, flat); - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p3, p0), - _mm_subs_epu8(p0, p3)), - _mm_or_si128(_mm_subs_epu8(q3, q0), - _mm_subs_epu8(q0, q3))); - flat = _mm_max_epu8(work, flat); - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p4, p0), - _mm_subs_epu8(p0, p4)), - _mm_or_si128(_mm_subs_epu8(q4, q0), - _mm_subs_epu8(q0, q4))); - flat = _mm_subs_epu8(flat, one); - flat = _mm_cmpeq_epi8(flat, zero); - flat = _mm_and_si128(flat, mask); - - p5 = _mm_loadu_si128((__m128i *)(s - 6 * p)); - q5 = _mm_loadu_si128((__m128i *)(s + 5 * p)); - flat2 = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p5, p0), - _mm_subs_epu8(p0, p5)), - _mm_or_si128(_mm_subs_epu8(q5, q0), - _mm_subs_epu8(q0, q5))); - _mm_store_si128((__m128i *)&ap[5 * 16], p5); - _mm_store_si128((__m128i *)&aq[5 * 16], q5); - flat2 = _mm_max_epu8(work, flat2); - p6 = _mm_loadu_si128((__m128i *)(s - 7 * p)); - q6 = _mm_loadu_si128((__m128i *)(s + 6 * p)); - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p6, p0), - _mm_subs_epu8(p0, p6)), - _mm_or_si128(_mm_subs_epu8(q6, q0), - _mm_subs_epu8(q0, q6))); - _mm_store_si128((__m128i *)&ap[6 * 16], p6); - _mm_store_si128((__m128i *)&aq[6 * 16], q6); - flat2 = _mm_max_epu8(work, flat2); - - p7 = _mm_loadu_si128((__m128i *)(s - 8 * p)); - q7 = _mm_loadu_si128((__m128i *)(s + 7 * p)); - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(p7, p0), - _mm_subs_epu8(p0, p7)), - _mm_or_si128(_mm_subs_epu8(q7, q0), - _mm_subs_epu8(q0, q7))); - _mm_store_si128((__m128i *)&ap[7 * 16], p7); - _mm_store_si128((__m128i *)&aq[7 * 16], q7); - flat2 = _mm_max_epu8(work, flat2); - flat2 = _mm_subs_epu8(flat2, one); - flat2 = _mm_cmpeq_epi8(flat2, zero); - flat2 = _mm_and_si128(flat2, flat); // flat2 & flat & mask + const __m128i four = _mm_set1_epi16(4); + const __m128i p3_lo = _mm_unpacklo_epi8(p3, zero); + const __m128i p2_lo = _mm_unpacklo_epi8(p2, zero); + const __m128i p1_lo = _mm_unpacklo_epi8(p1, zero); + const __m128i p0_lo = _mm_unpacklo_epi8(p0, zero); + const __m128i q0_lo = _mm_unpacklo_epi8(q0, zero); + const __m128i q1_lo = _mm_unpacklo_epi8(q1, zero); + const __m128i q2_lo = _mm_unpacklo_epi8(q2, zero); + const __m128i q3_lo = _mm_unpacklo_epi8(q3, zero); + + const __m128i p3_hi = _mm_unpackhi_epi8(p3, zero); + const __m128i p2_hi = _mm_unpackhi_epi8(p2, zero); + const __m128i p1_hi = _mm_unpackhi_epi8(p1, zero); + const __m128i p0_hi = _mm_unpackhi_epi8(p0, zero); + const __m128i q0_hi = _mm_unpackhi_epi8(q0, zero); + const __m128i q1_hi = _mm_unpackhi_epi8(q1, zero); + const __m128i q2_hi = _mm_unpackhi_epi8(q2, zero); + const __m128i q3_hi = _mm_unpackhi_epi8(q3, zero); + __m128i f8_lo, f8_hi; + + f8_lo = _mm_add_epi16(_mm_add_epi16(p3_lo, four), + _mm_add_epi16(p3_lo, p2_lo)); + f8_lo = _mm_add_epi16(_mm_add_epi16(p3_lo, f8_lo), + _mm_add_epi16(p2_lo, p1_lo)); + f8_lo = _mm_add_epi16(_mm_add_epi16(p0_lo, q0_lo), f8_lo); + + f8_hi = _mm_add_epi16(_mm_add_epi16(p3_hi, four), + _mm_add_epi16(p3_hi, p2_hi)); + f8_hi = _mm_add_epi16(_mm_add_epi16(p3_hi, f8_hi), + _mm_add_epi16(p2_hi, p1_hi)); + f8_hi = _mm_add_epi16(_mm_add_epi16(p0_hi, q0_hi), f8_hi); + + op2 = filter8_mask(flat, p2, f8_lo, f8_hi); + + f8_lo = filter_add2_sub2(f8_lo, q1_lo, p1_lo, p2_lo, p3_lo); + f8_hi = filter_add2_sub2(f8_hi, q1_hi, p1_hi, p2_hi, p3_hi); + op1 = filter8_mask(flat, op1, f8_lo, f8_hi); + + f8_lo = filter_add2_sub2(f8_lo, q2_lo, p0_lo, p1_lo, p3_lo); + f8_hi = filter_add2_sub2(f8_hi, q2_hi, p0_hi, p1_hi, p3_hi); + op0 = filter8_mask(flat, op0, f8_lo, f8_hi); + + f8_lo = filter_add2_sub2(f8_lo, q3_lo, q0_lo, p0_lo, p3_lo); + f8_hi = filter_add2_sub2(f8_hi, q3_hi, q0_hi, p0_hi, p3_hi); + oq0 = filter8_mask(flat, oq0, f8_lo, f8_hi); + + f8_lo = filter_add2_sub2(f8_lo, q3_lo, q1_lo, q0_lo, p2_lo); + f8_hi = filter_add2_sub2(f8_hi, q3_hi, q1_hi, q0_hi, p2_hi); + oq1 = filter8_mask(flat, oq1, f8_lo, f8_hi); + + f8_lo = filter_add2_sub2(f8_lo, q3_lo, q2_lo, q1_lo, p1_lo); + f8_hi = filter_add2_sub2(f8_hi, q3_hi, q2_hi, q1_hi, p1_hi); + oq2 = filter8_mask(flat, q2, f8_lo, f8_hi); } // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - // flat and wide flat calculations + // wide flat calculations { const __m128i eight = _mm_set1_epi16(8); - const __m128i four = _mm_set1_epi16(4); - __m128i temp_flat2 = flat2; - unsigned char *src = s; - int i = 0; - do { - __m128i workp_shft; - __m128i a, b, c; - - unsigned int off = i * 8; - p7 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[7 * 16] + off)), - zero); - p6 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[6 * 16] + off)), - zero); - p5 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[5 * 16] + off)), - zero); - p4 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[4 * 16] + off)), - zero); - p3 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[3 * 16] + off)), - zero); - p2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[2 * 16] + off)), - zero); - p1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[1 * 16] + off)), - zero); - p0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&ap[0 * 16] + off)), - zero); - q0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[0 * 16] + off)), - zero); - q1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[1 * 16] + off)), - zero); - q2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[2 * 16] + off)), - zero); - q3 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[3 * 16] + off)), - zero); - q4 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[4 * 16] + off)), - zero); - q5 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[5 * 16] + off)), - zero); - q6 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[6 * 16] + off)), - zero); - q7 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(&aq[7 * 16] + off)), - zero); - - c = _mm_sub_epi16(_mm_slli_epi16(p7, 3), p7); // p7 * 7 - c = _mm_add_epi16(_mm_slli_epi16(p6, 1), _mm_add_epi16(p4, c)); - - b = _mm_add_epi16(_mm_add_epi16(p3, four), _mm_add_epi16(p3, p2)); - a = _mm_add_epi16(p3, _mm_add_epi16(p2, p1)); - a = _mm_add_epi16(_mm_add_epi16(p0, q0), a); - - _mm_storel_epi64((__m128i *)&flat_op[2 * 16 + i * 8], - _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(a, b), 3) - , b)); - - c = _mm_add_epi16(_mm_add_epi16(p5, eight), c); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[6 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q1, a); - b = _mm_add_epi16(_mm_sub_epi16(b, _mm_add_epi16(p3, p2)), p1); - _mm_storel_epi64((__m128i *)&flat_op[1 * 16 + i * 8], - _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(a, b), 3) - , b)); - - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p6)), p5); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[5 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q2, a); - b = _mm_add_epi16(_mm_sub_epi16(b, _mm_add_epi16(p3, p1)), p0); - _mm_storel_epi64((__m128i *)&flat_op[i * 8], - _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(a, b), 3) - , b)); - - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p5)), p4); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[4 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q3, a); - b = _mm_add_epi16(_mm_sub_epi16(b, _mm_add_epi16(p3, p0)), q0); - _mm_storel_epi64((__m128i *)&flat_oq[i * 8], - _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(a, b), 3) - , b)); - - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p4)), p3); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[3 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - b = _mm_add_epi16(q3, b); - b = _mm_add_epi16(_mm_sub_epi16(b, _mm_add_epi16(p2, q0)), q1); - _mm_storel_epi64((__m128i *)&flat_oq[16 + i * 8], - _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(a, b), 3) - , b)); - - c = _mm_add_epi16(q4, c); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p3)), p2); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[2 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - b = _mm_add_epi16(q3, b); - b = _mm_add_epi16(_mm_sub_epi16(b, _mm_add_epi16(p1, q1)), q2); - _mm_storel_epi64((__m128i *)&flat_oq[2 * 16 + i * 8], - _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(a, b), 3) - , b)); - a = _mm_add_epi16(q5, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p2)), p1); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q6, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p1)), p0); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_op[i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p7, p0)), q0); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p6, q0)), q1); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p5, q1)), q2); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[2 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p4, q2)), q3); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[3 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p3, q3)), q4); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[4 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p2, q4)), q5); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[5 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - a = _mm_add_epi16(q7, a); - c = _mm_add_epi16(_mm_sub_epi16(c, _mm_add_epi16(p1, q5)), q6); - workp_shft = _mm_srli_epi16(_mm_add_epi16(a, c), 4); - _mm_storel_epi64((__m128i *)&flat2_oq[6 * 16 + i * 8], - _mm_packus_epi16(workp_shft, workp_shft)); - - temp_flat2 = _mm_srli_si128(temp_flat2, 8); - src += 8; - } while (++i < 2); + const __m128i p7_lo = _mm_unpacklo_epi8(p7, zero); + const __m128i p6_lo = _mm_unpacklo_epi8(p6, zero); + const __m128i p5_lo = _mm_unpacklo_epi8(p5, zero); + const __m128i p4_lo = _mm_unpacklo_epi8(p4, zero); + const __m128i p3_lo = _mm_unpacklo_epi8(p3, zero); + const __m128i p2_lo = _mm_unpacklo_epi8(p2, zero); + const __m128i p1_lo = _mm_unpacklo_epi8(p1, zero); + const __m128i p0_lo = _mm_unpacklo_epi8(p0, zero); + const __m128i q0_lo = _mm_unpacklo_epi8(q0, zero); + const __m128i q1_lo = _mm_unpacklo_epi8(q1, zero); + const __m128i q2_lo = _mm_unpacklo_epi8(q2, zero); + const __m128i q3_lo = _mm_unpacklo_epi8(q3, zero); + const __m128i q4_lo = _mm_unpacklo_epi8(q4, zero); + const __m128i q5_lo = _mm_unpacklo_epi8(q5, zero); + const __m128i q6_lo = _mm_unpacklo_epi8(q6, zero); + const __m128i q7_lo = _mm_unpacklo_epi8(q7, zero); + + const __m128i p7_hi = _mm_unpackhi_epi8(p7, zero); + const __m128i p6_hi = _mm_unpackhi_epi8(p6, zero); + const __m128i p5_hi = _mm_unpackhi_epi8(p5, zero); + const __m128i p4_hi = _mm_unpackhi_epi8(p4, zero); + const __m128i p3_hi = _mm_unpackhi_epi8(p3, zero); + const __m128i p2_hi = _mm_unpackhi_epi8(p2, zero); + const __m128i p1_hi = _mm_unpackhi_epi8(p1, zero); + const __m128i p0_hi = _mm_unpackhi_epi8(p0, zero); + const __m128i q0_hi = _mm_unpackhi_epi8(q0, zero); + const __m128i q1_hi = _mm_unpackhi_epi8(q1, zero); + const __m128i q2_hi = _mm_unpackhi_epi8(q2, zero); + const __m128i q3_hi = _mm_unpackhi_epi8(q3, zero); + const __m128i q4_hi = _mm_unpackhi_epi8(q4, zero); + const __m128i q5_hi = _mm_unpackhi_epi8(q5, zero); + const __m128i q6_hi = _mm_unpackhi_epi8(q6, zero); + const __m128i q7_hi = _mm_unpackhi_epi8(q7, zero); + + __m128i f_lo; + __m128i f_hi; + + f_lo = _mm_sub_epi16(_mm_slli_epi16(p7_lo, 3), p7_lo); // p7 * 7 + f_lo = _mm_add_epi16(_mm_slli_epi16(p6_lo, 1), + _mm_add_epi16(p4_lo, f_lo)); + f_lo = _mm_add_epi16(_mm_add_epi16(p3_lo, f_lo), + _mm_add_epi16(p2_lo, p1_lo)); + f_lo = _mm_add_epi16(_mm_add_epi16(p0_lo, q0_lo), f_lo); + f_lo = _mm_add_epi16(_mm_add_epi16(p5_lo, eight), f_lo); + + f_hi = _mm_sub_epi16(_mm_slli_epi16(p7_hi, 3), p7_hi); // p7 * 7 + f_hi = _mm_add_epi16(_mm_slli_epi16(p6_hi, 1), + _mm_add_epi16(p4_hi, f_hi)); + f_hi = _mm_add_epi16(_mm_add_epi16(p3_hi, f_hi), + _mm_add_epi16(p2_hi, p1_hi)); + f_hi = _mm_add_epi16(_mm_add_epi16(p0_hi, q0_hi), f_hi); + f_hi = _mm_add_epi16(_mm_add_epi16(p5_hi, eight), f_hi); + + p6 = filter16_mask(flat2, p6, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 7 * p), p6); + + f_lo = filter_add2_sub2(f_lo, q1_lo, p5_lo, p6_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q1_hi, p5_hi, p6_hi, p7_hi); + p5 = filter16_mask(flat2, p5, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 6 * p), p5); + + f_lo = filter_add2_sub2(f_lo, q2_lo, p4_lo, p5_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q2_hi, p4_hi, p5_hi, p7_hi); + p4 = filter16_mask(flat2, p4, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 5 * p), p4); + + f_lo = filter_add2_sub2(f_lo, q3_lo, p3_lo, p4_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q3_hi, p3_hi, p4_hi, p7_hi); + p3 = filter16_mask(flat2, p3, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 4 * p), p3); + + f_lo = filter_add2_sub2(f_lo, q4_lo, p2_lo, p3_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q4_hi, p2_hi, p3_hi, p7_hi); + op2 = filter16_mask(flat2, op2, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 3 * p), op2); + + f_lo = filter_add2_sub2(f_lo, q5_lo, p1_lo, p2_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q5_hi, p1_hi, p2_hi, p7_hi); + op1 = filter16_mask(flat2, op1, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 2 * p), op1); + + f_lo = filter_add2_sub2(f_lo, q6_lo, p0_lo, p1_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q6_hi, p0_hi, p1_hi, p7_hi); + op0 = filter16_mask(flat2, op0, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 1 * p), op0); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q0_lo, p0_lo, p7_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q0_hi, p0_hi, p7_hi); + oq0 = filter16_mask(flat2, oq0, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s - 0 * p), oq0); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q1_lo, p6_lo, q0_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q1_hi, p6_hi, q0_hi); + oq1 = filter16_mask(flat2, oq1, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s + 1 * p), oq1); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q2_lo, p5_lo, q1_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q2_hi, p5_hi, q1_hi); + oq2 = filter16_mask(flat2, oq2, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s + 2 * p), oq2); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q3_lo, p4_lo, q2_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q3_hi, p4_hi, q2_hi); + q3 = filter16_mask(flat2, q3, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s + 3 * p), q3); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q4_lo, p3_lo, q3_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q4_hi, p3_hi, q3_hi); + q4 = filter16_mask(flat2, q4, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s + 4 * p), q4); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q5_lo, p2_lo, q4_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q5_hi, p2_hi, q4_hi); + q5 = filter16_mask(flat2, q5, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s + 5 * p), q5); + + f_lo = filter_add2_sub2(f_lo, q7_lo, q6_lo, p1_lo, q5_lo); + f_hi = filter_add2_sub2(f_hi, q7_hi, q6_hi, p1_hi, q5_hi); + q6 = filter16_mask(flat2, q6, f_lo, f_hi); + _mm_storeu_si128((__m128i *)(s + 6 * p), q6); } // wide flat // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - work_a = _mm_load_si128((__m128i *)&ap[2 * 16]); - p2 = _mm_load_si128((__m128i *)&flat_op[2 * 16]); - work_a = _mm_andnot_si128(flat, work_a); - p2 = _mm_and_si128(flat, p2); - p2 = _mm_or_si128(work_a, p2); - _mm_store_si128((__m128i *)&flat_op[2 * 16], p2); - - p1 = _mm_load_si128((__m128i *)&flat_op[1 * 16]); - work_a = _mm_andnot_si128(flat, ps1); - p1 = _mm_and_si128(flat, p1); - p1 = _mm_or_si128(work_a, p1); - _mm_store_si128((__m128i *)&flat_op[1 * 16], p1); - - p0 = _mm_load_si128((__m128i *)&flat_op[0]); - work_a = _mm_andnot_si128(flat, ps0); - p0 = _mm_and_si128(flat, p0); - p0 = _mm_or_si128(work_a, p0); - _mm_store_si128((__m128i *)&flat_op[0], p0); - - q0 = _mm_load_si128((__m128i *)&flat_oq[0]); - work_a = _mm_andnot_si128(flat, qs0); - q0 = _mm_and_si128(flat, q0); - q0 = _mm_or_si128(work_a, q0); - _mm_store_si128((__m128i *)&flat_oq[0], q0); - - q1 = _mm_load_si128((__m128i *)&flat_oq[1 * 16]); - work_a = _mm_andnot_si128(flat, qs1); - q1 = _mm_and_si128(flat, q1); - q1 = _mm_or_si128(work_a, q1); - _mm_store_si128((__m128i *)&flat_oq[1 * 16], q1); - - work_a = _mm_load_si128((__m128i *)&aq[2 * 16]); - q2 = _mm_load_si128((__m128i *)&flat_oq[2 * 16]); - work_a = _mm_andnot_si128(flat, work_a); - q2 = _mm_and_si128(flat, q2); - q2 = _mm_or_si128(work_a, q2); - _mm_store_si128((__m128i *)&flat_oq[2 * 16], q2); - - // write out op6 - op3 - { - unsigned char *dst = (s - 7 * p); - for (i = 6; i > 2; i--) { - __m128i flat2_output; - work_a = _mm_load_si128((__m128i *)&ap[i * 16]); - flat2_output = _mm_load_si128((__m128i *)&flat2_op[i * 16]); - work_a = _mm_andnot_si128(flat2, work_a); - flat2_output = _mm_and_si128(flat2, flat2_output); - work_a = _mm_or_si128(work_a, flat2_output); - _mm_storeu_si128((__m128i *)dst, work_a); - dst += p; - } - } - - work_a = _mm_load_si128((__m128i *)&flat_op[2 * 16]); - p2 = _mm_load_si128((__m128i *)&flat2_op[2 * 16]); - work_a = _mm_andnot_si128(flat2, work_a); - p2 = _mm_and_si128(flat2, p2); - p2 = _mm_or_si128(work_a, p2); - _mm_storeu_si128((__m128i *)(s - 3 * p), p2); - - work_a = _mm_load_si128((__m128i *)&flat_op[1 * 16]); - p1 = _mm_load_si128((__m128i *)&flat2_op[1 * 16]); - work_a = _mm_andnot_si128(flat2, work_a); - p1 = _mm_and_si128(flat2, p1); - p1 = _mm_or_si128(work_a, p1); - _mm_storeu_si128((__m128i *)(s - 2 * p), p1); - - work_a = _mm_load_si128((__m128i *)&flat_op[0]); - p0 = _mm_load_si128((__m128i *)&flat2_op[0]); - work_a = _mm_andnot_si128(flat2, work_a); - p0 = _mm_and_si128(flat2, p0); - p0 = _mm_or_si128(work_a, p0); - _mm_storeu_si128((__m128i *)(s - 1 * p), p0); - - work_a = _mm_load_si128((__m128i *)&flat_oq[0]); - q0 = _mm_load_si128((__m128i *)&flat2_oq[0]); - work_a = _mm_andnot_si128(flat2, work_a); - q0 = _mm_and_si128(flat2, q0); - q0 = _mm_or_si128(work_a, q0); - _mm_storeu_si128((__m128i *)(s - 0 * p), q0); - - work_a = _mm_load_si128((__m128i *)&flat_oq[1 * 16]); - q1 = _mm_load_si128((__m128i *)&flat2_oq[16]); - work_a = _mm_andnot_si128(flat2, work_a); - q1 = _mm_and_si128(flat2, q1); - q1 = _mm_or_si128(work_a, q1); - _mm_storeu_si128((__m128i *)(s + 1 * p), q1); - - work_a = _mm_load_si128((__m128i *)&flat_oq[2 * 16]); - q2 = _mm_load_si128((__m128i *)&flat2_oq[2 * 16]); - work_a = _mm_andnot_si128(flat2, work_a); - q2 = _mm_and_si128(flat2, q2); - q2 = _mm_or_si128(work_a, q2); - _mm_storeu_si128((__m128i *)(s + 2 * p), q2); - - // write out oq3 - oq7 - { - unsigned char *dst = (s + 3 * p); - for (i = 3; i < 7; i++) { - __m128i flat2_output; - work_a = _mm_load_si128((__m128i *)&aq[i * 16]); - flat2_output = _mm_load_si128((__m128i *)&flat2_oq[i * 16]); - work_a = _mm_andnot_si128(flat2, work_a); - flat2_output = _mm_and_si128(flat2, flat2_output); - work_a = _mm_or_si128(work_a, flat2_output); - _mm_storeu_si128((__m128i *)dst, work_a); - dst += p; - } - } } } @@ -893,14 +755,11 @@ void vp9_lpf_horizontal_8_sse2(unsigned char *s, int p, const __m128i fe = _mm_set1_epi8(0xfe); const __m128i ff = _mm_cmpeq_epi8(fe, fe); __m128i abs_p1q1, abs_p0q0, abs_q1q0, abs_p1p0, work; - abs_p1p0 = _mm_or_si128(_mm_subs_epu8(q1p1, q0p0), - _mm_subs_epu8(q0p0, q1p1)); + abs_p1p0 = abs_diff(q1p1, q0p0); abs_q1q0 = _mm_srli_si128(abs_p1p0, 8); - abs_p0q0 = _mm_or_si128(_mm_subs_epu8(q0p0, p0q0), - _mm_subs_epu8(p0q0, q0p0)); - abs_p1q1 = _mm_or_si128(_mm_subs_epu8(q1p1, p1q1), - _mm_subs_epu8(p1q1, q1p1)); + abs_p0q0 = abs_diff(q0p0, p0q0); + abs_p1q1 = abs_diff(q1p1, p1q1); flat = _mm_max_epu8(abs_p1p0, abs_q1q0); hev = _mm_subs_epu8(flat, thresh); hev = _mm_xor_si128(_mm_cmpeq_epi8(hev, zero), ff); @@ -914,10 +773,8 @@ void vp9_lpf_horizontal_8_sse2(unsigned char *s, int p, // mask |= (abs(p1 - p0) > limit) * -1; // mask |= (abs(q1 - q0) > limit) * -1; - work = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q2p2, q1p1), - _mm_subs_epu8(q1p1, q2p2)), - _mm_or_si128(_mm_subs_epu8(q3p3, q2p2), - _mm_subs_epu8(q2p2, q3p3))); + work = _mm_max_epu8(abs_diff(q2p2, q1p1), + abs_diff(q3p3, q2p2)); mask = _mm_max_epu8(work, mask); mask = _mm_max_epu8(mask, _mm_srli_si128(mask, 8)); mask = _mm_subs_epu8(mask, limit); @@ -925,10 +782,8 @@ void vp9_lpf_horizontal_8_sse2(unsigned char *s, int p, // flat_mask4 - flat = _mm_max_epu8(_mm_or_si128(_mm_subs_epu8(q2p2, q0p0), - _mm_subs_epu8(q0p0, q2p2)), - _mm_or_si128(_mm_subs_epu8(q3p3, q0p0), - _mm_subs_epu8(q0p0, q3p3))); + flat = _mm_max_epu8(abs_diff(q2p2, q0p0), + abs_diff(q3p3, q0p0)); flat = _mm_max_epu8(abs_p1p0, flat); flat = _mm_max_epu8(flat, _mm_srli_si128(flat, 8)); flat = _mm_subs_epu8(flat, one); diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c index df82be5ec..e9b5aa258 100644 --- a/vp9/encoder/vp9_firstpass.c +++ b/vp9/encoder/vp9_firstpass.c @@ -35,26 +35,28 @@ #include "vp9/encoder/vp9_rd.h" #include "vp9/encoder/vp9_variance.h" -#define OUTPUT_FPF 0 - -#define IIFACTOR 12.5 -#define IIKFACTOR1 12.5 -#define IIKFACTOR2 15.0 -#define RMAX 512.0 -#define GF_RMAX 96.0 -#define ERR_DIVISOR 150.0 -#define MIN_DECAY_FACTOR 0.1 -#define SVC_FACTOR_PT_LOW 0.45 -#define FACTOR_PT_LOW 0.5 -#define FACTOR_PT_HIGH 0.9 - -#define KF_MB_INTRA_MIN 150 -#define GF_MB_INTRA_MIN 100 +#define OUTPUT_FPF 0 +#define ARF_STATS_OUTPUT 0 + +#define BOOST_FACTOR 12.5 +#define ERR_DIVISOR 100.0 +#define FACTOR_PT_LOW 0.5 +#define FACTOR_PT_HIGH 0.9 +#define FIRST_PASS_Q 10.0 +#define GF_MAX_BOOST 96.0 +#define INTRA_MODE_PENALTY 1024 +#define KF_MAX_BOOST 128.0 +#define MIN_DECAY_FACTOR 0.01 +#define MIN_GF_INTERVAL 4 +#define MIN_KF_BOOST 300 +#define NEW_MV_MODE_PENALTY 32 +#define SVC_FACTOR_PT_LOW 0.45 #define DOUBLE_DIVIDE_CHECK(x) ((x) < 0 ? (x) - 0.000001 : (x) + 0.000001) -#define MIN_KF_BOOST 300 -#define MIN_GF_INTERVAL 4 +#if ARF_STATS_OUTPUT +unsigned int arf_count = 0; +#endif static void swap_yv12(YV12_BUFFER_CONFIG *a, YV12_BUFFER_CONFIG *b) { YV12_BUFFER_CONFIG temp = *a; @@ -299,7 +301,7 @@ static void first_pass_motion_search(VP9_COMP *cpi, MACROBLOCK *x, int num00, tmp_err, n; const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize]; - const int new_mv_mode_penalty = 256; + const int new_mv_mode_penalty = NEW_MV_MODE_PENALTY; int step_param = 3; int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param; @@ -364,7 +366,7 @@ static int find_fp_qindex(vpx_bit_depth_t bit_depth) { int i; for (i = 0; i < QINDEX_RANGE; ++i) - if (vp9_convert_qindex_to_q(i, bit_depth) >= 30.0) + if (vp9_convert_qindex_to_q(i, bit_depth) >= FIRST_PASS_Q) break; if (i == QINDEX_RANGE) @@ -414,7 +416,7 @@ void vp9_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) { int mvcount = 0; int intercount = 0; int second_ref_count = 0; - int intrapenalty = 256; + const int intrapenalty = INTRA_MODE_PENALTY; int neutral_count = 0; int new_mv_count = 0; int sum_in_vectors = 0; @@ -830,12 +832,18 @@ void vp9_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) { vp9_clear_system_state(); { FIRSTPASS_STATS fps; + // The minimum error here insures some bit alocation to frames even + // in static regions. The allocation per MB declines for larger formats + // where the typical "real" energy per MB also falls. + // Initial estimate here uses sqrt(mbs) to define the min_err, where the + // number of mbs is propotional to image area. + const double min_err = 200 * sqrt(cm->MBs); fps.frame = cm->current_video_frame; fps.spatial_layer_id = cpi->svc.spatial_layer_id; - fps.intra_error = (double)(intra_error >> 8); - fps.coded_error = (double)(coded_error >> 8); - fps.sr_coded_error = (double)(sr_coded_error >> 8); + fps.coded_error = (double)(coded_error >> 8) + min_err; + fps.sr_coded_error = (double)(sr_coded_error >> 8) + min_err; + fps.intra_error = (double)(intra_error >> 8) + min_err; fps.count = 1.0; fps.pcnt_inter = (double)intercount / cm->MBs; fps.pcnt_second_ref = (double)second_ref_count / cm->MBs; @@ -1033,17 +1041,6 @@ void vp9_init_second_pass(VP9_COMP *cpi) { 10000000.0); } - // Calculate a minimum intra value to be used in determining the IIratio - // scores used in the second pass. We have this minimum to make sure - // that clips that are static but "low complexity" in the intra domain - // are still boosted appropriately for KF/GF/ARF. - if (!is_two_pass_svc) { - // We don't know the number of MBs for each layer at this point. - // So we will do it later. - twopass->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs; - twopass->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs; - } - // This variable monitors how far behind the second ref update is lagging. twopass->sr_update_lag = 1; @@ -1067,34 +1064,58 @@ void vp9_init_second_pass(VP9_COMP *cpi) { // Reset the vbr bits off target counter cpi->rc.vbr_bits_off_target = 0; + + // Static sequence monitor variables. + twopass->kf_zeromotion_pct = 100; + twopass->last_kfgroup_zeromotion_pct = 100; } -// This function gives an estimate of how badly we believe the prediction -// quality is decaying from frame to frame. -static double get_prediction_decay_rate(const VP9_COMMON *cm, - const FIRSTPASS_STATS *next_frame) { - // Look at the observed drop in prediction quality between the last frame - // and the GF buffer (which contains an older frame). - const double mb_sr_err_diff = (next_frame->sr_coded_error - - next_frame->coded_error) / cm->MBs; - const double second_ref_decay = mb_sr_err_diff <= 512.0 - ? fclamp(pow(1.0 - (mb_sr_err_diff / 512.0), 0.5), 0.85, 1.0) - : 0.85; - - return MIN(second_ref_decay, next_frame->pcnt_inter); +#define SR_DIFF_PART 0.0015 +#define MOTION_AMP_PART 0.003 +#define INTRA_PART 0.005 +#define DEFAULT_DECAY_LIMIT 0.75 +#define LOW_SR_DIFF_TRHESH 0.1 +#define SR_DIFF_MAX 128.0 + +static double get_sr_decay_rate(const VP9_COMMON *cm, + const FIRSTPASS_STATS *frame) { + double sr_diff = (frame->sr_coded_error - frame->coded_error) / cm->MBs; + double sr_decay = 1.0; + const double motion_amplitude_factor = + frame->pcnt_motion * ((frame->mvc_abs + frame->mvr_abs) / 2); + const double pcnt_intra = 100 * (1.0 - frame->pcnt_inter); + + if ((sr_diff > LOW_SR_DIFF_TRHESH)) { + sr_diff = MIN(sr_diff, SR_DIFF_MAX); + sr_decay = 1.0 - (SR_DIFF_PART * sr_diff) - + (MOTION_AMP_PART * motion_amplitude_factor) - + (INTRA_PART * pcnt_intra); + } + return MAX(sr_decay, MIN(DEFAULT_DECAY_LIMIT, frame->pcnt_inter)); } // This function gives an estimate of how badly we believe the prediction // quality is decaying from frame to frame. -static double get_zero_motion_factor(const FIRSTPASS_STATS *frame) { - const double sr_ratio = frame->coded_error / - DOUBLE_DIVIDE_CHECK(frame->sr_coded_error); +static double get_zero_motion_factor(const VP9_COMMON *cm, + const FIRSTPASS_STATS *frame) { const double zero_motion_pct = frame->pcnt_inter - frame->pcnt_motion; - - return MIN(sr_ratio, zero_motion_pct); + double sr_decay = get_sr_decay_rate(cm, frame); + return MIN(sr_decay, zero_motion_pct); } +#define ZM_POWER_FACTOR 0.75 + +static double get_prediction_decay_rate(const VP9_COMMON *cm, + const FIRSTPASS_STATS *next_frame) { + const double sr_decay_rate = get_sr_decay_rate(cm, next_frame); + const double zero_motion_factor = + (0.95 * pow((next_frame->pcnt_inter - next_frame->pcnt_motion), + ZM_POWER_FACTOR)); + + return MAX(zero_motion_factor, + (sr_decay_rate + ((1.0 - sr_decay_rate) * zero_motion_factor))); +} // Function to test for a condition where a complex transition is followed // by a static section. For example in slide shows where there is a fade @@ -1172,19 +1193,17 @@ static void accumulate_frame_motion_stats(const FIRSTPASS_STATS *stats, } } -// Calculate a baseline boost number for the current frame. -static double calc_frame_boost(const TWO_PASS *twopass, +#define BASELINE_ERR_PER_MB 1000.0 +static double calc_frame_boost(VP9_COMP *cpi, const FIRSTPASS_STATS *this_frame, - double this_frame_mv_in_out) { + double this_frame_mv_in_out, + double max_boost) { double frame_boost; - // Underlying boost factor is based on inter intra error ratio. - if (this_frame->intra_error > twopass->gf_intra_err_min) - frame_boost = (IIFACTOR * this_frame->intra_error / - DOUBLE_DIVIDE_CHECK(this_frame->coded_error)); - else - frame_boost = (IIFACTOR * twopass->gf_intra_err_min / - DOUBLE_DIVIDE_CHECK(this_frame->coded_error)); + // Underlying boost factor is based on inter error ratio. + frame_boost = (BASELINE_ERR_PER_MB * cpi->common.MBs) / + DOUBLE_DIVIDE_CHECK(this_frame->coded_error); + frame_boost = frame_boost * BOOST_FACTOR; // Increase boost for frames where new data coming into frame (e.g. zoom out). // Slightly reduce boost if there is a net balance of motion out of the frame @@ -1195,7 +1214,7 @@ static double calc_frame_boost(const TWO_PASS *twopass, else frame_boost += frame_boost * (this_frame_mv_in_out / 2.0); - return MIN(frame_boost, GF_RMAX); + return MIN(frame_boost, max_boost); } static int calc_arf_boost(VP9_COMP *cpi, int offset, @@ -1236,8 +1255,9 @@ static int calc_arf_boost(VP9_COMP *cpi, int offset, ? MIN_DECAY_FACTOR : decay_accumulator; } - boost_score += decay_accumulator * calc_frame_boost(twopass, this_frame, - this_frame_mv_in_out); + boost_score += decay_accumulator * calc_frame_boost(cpi, this_frame, + this_frame_mv_in_out, + GF_MAX_BOOST); } *f_boost = (int)boost_score; @@ -1274,8 +1294,9 @@ static int calc_arf_boost(VP9_COMP *cpi, int offset, ? MIN_DECAY_FACTOR : decay_accumulator; } - boost_score += decay_accumulator * calc_frame_boost(twopass, this_frame, - this_frame_mv_in_out); + boost_score += decay_accumulator * calc_frame_boost(cpi, this_frame, + this_frame_mv_in_out, + GF_MAX_BOOST); } *b_boost = (int)boost_score; @@ -1585,7 +1606,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { gf_group_err -= gf_first_frame_err; // Motion breakout threshold for loop below depends on image size. - mv_ratio_accumulator_thresh = (cpi->common.width + cpi->common.height) / 10.0; + mv_ratio_accumulator_thresh = (cpi->common.width + cpi->common.height) / 4.0; // Work out a maximum interval for the GF group. // If the image appears almost completely static we can extend beyond this. @@ -1629,11 +1650,13 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { if (!flash_detected) { last_loop_decay_rate = loop_decay_rate; loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame); + decay_accumulator = decay_accumulator * loop_decay_rate; // Monitor for static sections. - zero_motion_accumulator = MIN(zero_motion_accumulator, - get_zero_motion_factor(&next_frame)); + zero_motion_accumulator = + MIN(zero_motion_accumulator, + get_zero_motion_factor(&cpi->common, &next_frame)); // Break clause to detect very still sections after motion. For example, // a static image after a fade or other transition. @@ -1645,8 +1668,9 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { } // Calculate a boost number for this frame. - boost_score += decay_accumulator * calc_frame_boost(twopass, &next_frame, - this_frame_mv_in_out); + boost_score += decay_accumulator * calc_frame_boost(cpi, &next_frame, + this_frame_mv_in_out, + GF_MAX_BOOST); // Break out conditions. if ( @@ -1655,38 +1679,21 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { ( // Don't break out with a very short interval. (i > MIN_GF_INTERVAL) && - ((boost_score > 125.0) || (next_frame.pcnt_inter < 0.75)) && (!flash_detected) && ((mv_ratio_accumulator > mv_ratio_accumulator_thresh) || (abs_mv_in_out_accumulator > 3.0) || (mv_in_out_accumulator < -2.0) || - ((boost_score - old_boost_score) < IIFACTOR)))) { + ((boost_score - old_boost_score) < BOOST_FACTOR)))) { boost_score = old_boost_score; break; } *this_frame = next_frame; - old_boost_score = boost_score; } twopass->gf_zeromotion_pct = (int)(zero_motion_accumulator * 1000.0); - // Don't allow a gf too near the next kf. - if ((rc->frames_to_key - i) < MIN_GF_INTERVAL) { - while (i < (rc->frames_to_key + !rc->next_key_frame_forced)) { - ++i; - - if (EOF == input_stats(twopass, this_frame)) - break; - - if (i < rc->frames_to_key) { - mod_frame_err = calculate_modified_err(twopass, oxcf, this_frame); - gf_group_err += mod_frame_err; - } - } - } - // Set the interval until the next gf. if (cpi->common.frame_type == KEY_FRAME || rc->source_alt_ref_active) rc->baseline_gf_interval = i - 1; @@ -1713,10 +1720,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { // Should we use the alternate reference frame. if (allow_alt_ref && (i < cpi->oxcf.lag_in_frames) && - (i >= MIN_GF_INTERVAL) && - // For real scene cuts (not forced kfs) don't allow arf very near kf. - (rc->next_key_frame_forced || - (i <= (rc->frames_to_key - MIN_GF_INTERVAL)))) { + (i >= MIN_GF_INTERVAL)) { // Calculate the boost for alt ref. rc->gfu_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost, &b_boost); @@ -1727,7 +1731,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { (cpi->multi_arf_allowed && (rc->baseline_gf_interval >= 6) && (zero_motion_accumulator < 0.995)) ? 1 : 0; } else { - rc->gfu_boost = (int)boost_score; + rc->gfu_boost = MAX((int)boost_score, 125); rc->source_alt_ref_pending = 0; } @@ -1782,6 +1786,9 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { } } +// TODO(PGW) Re-examine the use of II ration in this code in the light of# +// changes elsewhere +#define KF_II_MAX 128.0 static int test_candidate_kf(TWO_PASS *twopass, const FIRSTPASS_STATS *last_frame, const FIRSTPASS_STATS *this_frame, @@ -1811,11 +1818,11 @@ static int test_candidate_kf(TWO_PASS *twopass, // Examine how well the key frame predicts subsequent frames. for (i = 0; i < 16; ++i) { - double next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / + double next_iiratio = (BOOST_FACTOR * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)); - if (next_iiratio > RMAX) - next_iiratio = RMAX; + if (next_iiratio > KF_II_MAX) + next_iiratio = KF_II_MAX; // Cumulative effect of decay in prediction quality. if (local_next_frame.pcnt_inter > 0.85) @@ -1870,7 +1877,9 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { FIRSTPASS_STATS next_frame; FIRSTPASS_STATS last_frame; int kf_bits = 0; + int loop_decay_counter = 0; double decay_accumulator = 1.0; + double av_decay_accumulator = 0.0; double zero_motion_accumulator = 1.0; double boost_score = 0.0; double kf_mod_err = 0.0; @@ -2024,42 +2033,38 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { // Reset the first pass file position. reset_fpf_position(twopass, start_position); - // Scan through the kf group collating various stats used to deteermine + // Scan through the kf group collating various stats used to determine // how many bits to spend on it. decay_accumulator = 1.0; boost_score = 0.0; - for (i = 0; i < rc->frames_to_key; ++i) { + for (i = 0; i < (rc->frames_to_key - 1); ++i) { if (EOF == input_stats(twopass, &next_frame)) break; // Monitor for static sections. - zero_motion_accumulator =MIN(zero_motion_accumulator, - get_zero_motion_factor(&next_frame)); - - // For the first few frames collect data to decide kf boost. - if (i <= (rc->max_gf_interval * 2)) { - double r; - if (next_frame.intra_error > twopass->kf_intra_err_min) - r = (IIKFACTOR2 * next_frame.intra_error / - DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); - else - r = (IIKFACTOR2 * twopass->kf_intra_err_min / - DOUBLE_DIVIDE_CHECK(next_frame.coded_error)); + zero_motion_accumulator = + MIN(zero_motion_accumulator, + get_zero_motion_factor(&cpi->common, &next_frame)); - if (r > RMAX) - r = RMAX; + // Not all frames in the group are necessarily used in calculating boost. + if ((i <= rc->max_gf_interval) || + ((i <= (rc->max_gf_interval * 4)) && (decay_accumulator > 0.5))) { + const double frame_boost = + calc_frame_boost(cpi, this_frame, 0, KF_MAX_BOOST); // How fast is prediction quality decaying. if (!detect_flash(twopass, 0)) { - const double loop_decay_rate = get_prediction_decay_rate(&cpi->common, - &next_frame); + const double loop_decay_rate = + get_prediction_decay_rate(&cpi->common, &next_frame); decay_accumulator *= loop_decay_rate; decay_accumulator = MAX(decay_accumulator, MIN_DECAY_FACTOR); + av_decay_accumulator += decay_accumulator; + ++loop_decay_counter; } - - boost_score += (decay_accumulator * r); + boost_score += (decay_accumulator * frame_boost); } } + av_decay_accumulator /= (double)loop_decay_counter; reset_fpf_position(twopass, start_position); @@ -2071,14 +2076,12 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) { calculate_section_intra_ratio(start_position, twopass->stats_in_end, rc->frames_to_key); - // Work out how many bits to allocate for the key frame itself. - rc->kf_boost = (int)boost_score; - - if (rc->kf_boost < (rc->frames_to_key * 3)) - rc->kf_boost = (rc->frames_to_key * 3); - if (rc->kf_boost < MIN_KF_BOOST) - rc->kf_boost = MIN_KF_BOOST; + // Apply various clamps for min and max boost + rc->kf_boost = (int)(av_decay_accumulator * boost_score); + rc->kf_boost = MAX(rc->kf_boost, (rc->frames_to_key * 3)); + rc->kf_boost = MAX(rc->kf_boost, MIN_KF_BOOST); + // Work out how many bits to allocate for the key frame itself. kf_bits = calculate_boost_bits((rc->frames_to_key - 1), rc->kf_boost, twopass->kf_group_bits); @@ -2216,11 +2219,6 @@ void vp9_rc_get_second_pass_params(VP9_COMP *cpi) { vp9_clear_system_state(); - if (lc != NULL && twopass->kf_intra_err_min == 0) { - twopass->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs; - twopass->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs; - } - if (cpi->oxcf.rc_mode == VPX_Q) { twopass->active_worst_quality = cpi->oxcf.cq_level; } else if (cm->current_video_frame == 0 || @@ -2286,6 +2284,18 @@ void vp9_rc_get_second_pass_params(VP9_COMP *cpi) { rc->frames_till_gf_update_due = rc->baseline_gf_interval; if (lc != NULL) cpi->refresh_golden_frame = 1; + +#if ARF_STATS_OUTPUT + { + FILE *fpfile; + fpfile = fopen("arf.stt", "a"); + ++arf_count; + fprintf(fpfile, "%10d %10d %10d %10ld\n", + cm->current_video_frame, rc->kf_boost, arf_count, rc->gfu_boost); + + fclose(fpfile); + } +#endif } configure_buffer_updates(cpi); @@ -2325,6 +2335,7 @@ void vp9_twopass_postencode_update(VP9_COMP *cpi) { if (cpi->common.frame_type != KEY_FRAME && !vp9_is_upper_layer_key_frame(cpi)) { twopass->kf_group_bits -= bits_used; + twopass->last_kfgroup_zeromotion_pct = twopass->kf_zeromotion_pct; } twopass->kf_group_bits = MAX(twopass->kf_group_bits, 0); diff --git a/vp9/encoder/vp9_firstpass.h b/vp9/encoder/vp9_firstpass.h index aaa6b0311..0b82d32fa 100644 --- a/vp9/encoder/vp9_firstpass.h +++ b/vp9/encoder/vp9_firstpass.h @@ -93,8 +93,6 @@ typedef struct { double modified_error_min; double modified_error_max; double modified_error_left; - double kf_intra_err_min; - double gf_intra_err_min; #if CONFIG_FP_MB_STATS uint8_t *frame_mb_stats_buf; @@ -110,6 +108,7 @@ typedef struct { int sr_update_lag; int kf_zeromotion_pct; + int last_kfgroup_zeromotion_pct; int gf_zeromotion_pct; int active_worst_quality; diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c index 94c0b64dd..9b6c77398 100644 --- a/vp9/encoder/vp9_ratectrl.c +++ b/vp9/encoder/vp9_ratectrl.c @@ -126,10 +126,10 @@ static void init_minq_luts(int *kf_low_m, int *kf_high_m, int i; for (i = 0; i < QINDEX_RANGE; i++) { const double maxq = vp9_convert_qindex_to_q(i, bit_depth); - kf_low_m[i] = get_minq_index(maxq, 0.000001, -0.0004, 0.125, bit_depth); - kf_high_m[i] = get_minq_index(maxq, 0.000002, -0.0012, 0.50, bit_depth); + kf_low_m[i] = get_minq_index(maxq, 0.000001, -0.0004, 0.150, bit_depth); + kf_high_m[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.55, bit_depth); arfgf_low[i] = get_minq_index(maxq, 0.0000015, -0.0009, 0.30, bit_depth); - arfgf_high[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.50, bit_depth); + arfgf_high[i] = get_minq_index(maxq, 0.0000021, -0.00125, 0.55, bit_depth); inter[i] = get_minq_index(maxq, 0.00000271, -0.00113, 0.90, bit_depth); rtc[i] = get_minq_index(maxq, 0.00000271, -0.00113, 0.70, bit_depth); } @@ -175,7 +175,7 @@ int vp9_rc_bits_per_mb(FRAME_TYPE frame_type, int qindex, double correction_factor, vpx_bit_depth_t bit_depth) { const double q = vp9_convert_qindex_to_q(qindex, bit_depth); - int enumerator = frame_type == KEY_FRAME ? 3300000 : 2250000; + int enumerator = frame_type == KEY_FRAME ? 2700000 : 1800000; // q based adjustment to baseline enumerator enumerator += (int)(enumerator * q) >> 12; @@ -610,7 +610,7 @@ static int rc_pick_q_and_bounds_one_pass_cbr(const VP9_COMP *cpi, if (frame_is_intra_only(cm)) { active_best_quality = rc->best_quality; - // Handle the special case for key frames forced when we have75 reached + // Handle the special case for key frames forced when we have reached // the maximum key frame interval. Here force the Q to a range // based on the ambient Q to reduce the risk of popping. if (rc->this_key_frame_forced) { @@ -880,6 +880,7 @@ static int rc_pick_q_and_bounds_one_pass_vbr(const VP9_COMP *cpi, return q; } +#define STATIC_MOTION_THRESH 95 static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi, int *bottom_index, int *top_index) { @@ -894,16 +895,31 @@ static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi, ASSIGN_MINQ_TABLE(cm->bit_depth, inter_minq); if (frame_is_intra_only(cm) || vp9_is_upper_layer_key_frame(cpi)) { - // Handle the special case for key frames forced when we have75 reached + // Handle the special case for key frames forced when we have reached // the maximum key frame interval. Here force the Q to a range // based on the ambient Q to reduce the risk of popping. if (rc->this_key_frame_forced) { - int qindex = rc->last_boosted_qindex; - double last_boosted_q = vp9_convert_qindex_to_q(qindex, cm->bit_depth); - int delta_qindex = vp9_compute_qdelta(rc, last_boosted_q, - last_boosted_q * 0.75, - cm->bit_depth); - active_best_quality = MAX(qindex + delta_qindex, rc->best_quality); + double last_boosted_q; + int delta_qindex; + int qindex; + + if (cpi->twopass.last_kfgroup_zeromotion_pct >= STATIC_MOTION_THRESH) { + qindex = MIN(rc->last_kf_qindex, rc->last_boosted_qindex); + active_best_quality = qindex; + last_boosted_q = vp9_convert_qindex_to_q(qindex, cm->bit_depth); + delta_qindex = vp9_compute_qdelta(rc, last_boosted_q, + last_boosted_q * 1.25, + cm->bit_depth); + active_worst_quality = MIN(qindex + delta_qindex, active_worst_quality); + + } else { + qindex = rc->last_boosted_qindex; + last_boosted_q = vp9_convert_qindex_to_q(qindex, cm->bit_depth); + delta_qindex = vp9_compute_qdelta(rc, last_boosted_q, + last_boosted_q * 0.75, + cm->bit_depth); + active_best_quality = MAX(qindex + delta_qindex, rc->best_quality); + } } else { // Not forced keyframe. double q_adj_factor = 1.0; @@ -972,18 +988,12 @@ static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi, } } - // Clip the active best and worst quality values to limits. - active_best_quality = clamp(active_best_quality, - rc->best_quality, rc->worst_quality); - active_worst_quality = clamp(active_worst_quality, - active_best_quality, rc->worst_quality); - - *top_index = active_worst_quality; - *bottom_index = active_best_quality; - #if LIMIT_QRANGE_FOR_ALTREF_AND_KEY vp9_clear_system_state(); - { + // Static forced key frames Q restrictions dealt with elsewhere. + if (!((frame_is_intra_only(cm) || vp9_is_upper_layer_key_frame(cpi))) || + !rc->this_key_frame_forced || + (cpi->twopass.last_kfgroup_zeromotion_pct < STATIC_MOTION_THRESH)) { const GF_GROUP *const gf_group = &cpi->twopass.gf_group; const double rate_factor_deltas[RATE_FACTOR_LEVELS] = { 1.00, // INTER_NORMAL @@ -997,27 +1007,43 @@ static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi, int qdelta = vp9_compute_qdelta_by_rate(&cpi->rc, cm->frame_type, active_worst_quality, rate_factor, cm->bit_depth); - *top_index = active_worst_quality + qdelta; - *top_index = (*top_index > *bottom_index) ? *top_index : *bottom_index; + active_worst_quality = active_worst_quality + qdelta; + active_worst_quality = MAX(active_worst_quality, active_best_quality); } #endif + // Clip the active best and worst quality values to limits. + active_best_quality = clamp(active_best_quality, + rc->best_quality, rc->worst_quality); + active_worst_quality = clamp(active_worst_quality, + active_best_quality, rc->worst_quality); + if (oxcf->rc_mode == VPX_Q) { q = active_best_quality; // Special case code to try and match quality with forced key frames. - } else if ((cm->frame_type == KEY_FRAME) && rc->this_key_frame_forced) { - q = rc->last_boosted_qindex; + } else if ((frame_is_intra_only(cm) || vp9_is_upper_layer_key_frame(cpi)) && + rc->this_key_frame_forced) { + // If static since last kf use better of last boosted and last kf q. + if (cpi->twopass.last_kfgroup_zeromotion_pct >= STATIC_MOTION_THRESH) { + q = MIN(rc->last_kf_qindex, rc->last_boosted_qindex); + } else { + q = rc->last_boosted_qindex; + } } else { q = vp9_rc_regulate_q(cpi, rc->this_frame_target, active_best_quality, active_worst_quality); - if (q > *top_index) { + if (q > active_worst_quality) { // Special case when we are targeting the max allowed rate. if (rc->this_frame_target >= rc->max_frame_bandwidth) - *top_index = q; + active_worst_quality = q; else - q = *top_index; + q = active_worst_quality; } } + clamp(q, active_best_quality, active_worst_quality); + + *top_index = active_worst_quality; + *bottom_index = active_best_quality; assert(*top_index <= rc->worst_quality && *top_index >= rc->best_quality); @@ -1161,11 +1187,12 @@ void vp9_rc_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) { // better than that already stored. // This is used to help set quality in forced key frames to reduce popping if ((qindex < rc->last_boosted_qindex) || - ((cpi->static_mb_pct < 100) && - ((cm->frame_type == KEY_FRAME) || cpi->refresh_alt_ref_frame || + (((cm->frame_type == KEY_FRAME) || cpi->refresh_alt_ref_frame || (cpi->refresh_golden_frame && !rc->is_src_frame_alt_ref)))) { rc->last_boosted_qindex = qindex; } + if (cm->frame_type == KEY_FRAME) + rc->last_kf_qindex = qindex; update_buffer_level(cpi, rc->projected_frame_size); diff --git a/vp9/encoder/vp9_ratectrl.h b/vp9/encoder/vp9_ratectrl.h index 2ced8e6dd..edfb9fce9 100644 --- a/vp9/encoder/vp9_ratectrl.h +++ b/vp9/encoder/vp9_ratectrl.h @@ -42,6 +42,7 @@ typedef struct { int sb64_target_rate; int last_q[FRAME_TYPES]; // Separate values for Intra/Inter int last_boosted_qindex; // Last boosted GF/KF/ARF q + int last_kf_qindex; // Q index of the last key frame coded. int gfu_boost; int last_boost; |