Merge "Cleaning up pack_inter_mode_mvs() function."
diff --git a/docs.mk b/docs.mk
index 9426f76..797b466 100644
--- a/docs.mk
+++ b/docs.mk
@@ -30,7 +30,9 @@
EXAMPLE_PATH += $(SRC_PATH_BARE) #for CHANGELOG, README, etc
+EXAMPLE_PATH += $(SRC_PATH_BARE)/examples
+doxyfile: $(if $(findstring examples, $(ALL_TARGETS)),examples.doxy)
doxyfile: libs.doxy_template libs.doxy
@echo " [CREATE] $@"
@cat $^ > $@
diff --git a/examples.mk b/examples.mk
index e4abcf7..40756e1 100644
--- a/examples.mk
+++ b/examples.mk
@@ -285,3 +285,36 @@
$(addprefix bin/$(p)/,$(ALL_EXAMPLES_BASENAME:.c=.exe)))
$(foreach proj,$(call enabled,PROJECTS),\
$(eval $(call vcproj_template,$(proj))))
+
+#
+# Documentation Rules
+#
+%.dox: %.c
+ @echo " [DOXY] $@"
+ @echo "/*!\page example_$(@F:.dox=) $(@F:.dox=)" > $@
+ @echo " \includelineno $(<F)" >> $@
+ @echo "*/" >> $@
+
+samples.dox: examples.mk
+ @echo " [DOXY] $@"
+ @echo "/*!\page samples Sample Code" > $@
+ @echo " This SDK includes a number of sample applications."\
+ "Each sample documents a feature of the SDK in both prose"\
+ "and the associated C code."\
+ "The following samples are included: ">>$@
+ @$(foreach ex,$(sort $(notdir $(EXAMPLES:.c=))),\
+ echo " - \subpage example_$(ex) $($(ex).DESCRIPTION)" >> $@;)
+ @echo >> $@
+ @echo " In addition, the SDK contains a number of utilities."\
+ "Since these utilities are built upon the concepts described"\
+ "in the sample code listed above, they are not documented in"\
+ "pieces like the samples are. Their source is included here"\
+ "for reference. The following utilities are included:" >> $@
+ @$(foreach ex,$(sort $(UTILS:.c=)),\
+ echo " - \subpage example_$(ex) $($(ex).DESCRIPTION)" >> $@;)
+ @echo "*/" >> $@
+
+CLEAN-OBJS += examples.doxy samples.dox $(ALL_EXAMPLES:.c=.dox)
+DOCS-yes += examples.doxy samples.dox
+examples.doxy: samples.dox $(ALL_EXAMPLES:.c=.dox)
+ @echo "INPUT += $^" > $@
diff --git a/vp8/common/arm/armv6/vp8_variance16x16_armv6.asm b/vp8/common/arm/armv6/vp8_variance16x16_armv6.asm
index dc84c30..3991957 100644
--- a/vp8/common/arm/armv6/vp8_variance16x16_armv6.asm
+++ b/vp8/common/arm/armv6/vp8_variance16x16_armv6.asm
@@ -53,7 +53,7 @@
orr r6, r6, r7 ; differences of all 4 pixels
; calculate total sum
adds r8, r8, r4 ; add positive differences to sum
- subs r8, r8, r5 ; substract negative differences from sum
+ subs r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -77,7 +77,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -101,7 +101,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -127,7 +127,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
diff --git a/vp8/common/arm/armv6/vp8_variance8x8_armv6.asm b/vp8/common/arm/armv6/vp8_variance8x8_armv6.asm
index adc353d..915ee49 100644
--- a/vp8/common/arm/armv6/vp8_variance8x8_armv6.asm
+++ b/vp8/common/arm/armv6/vp8_variance8x8_armv6.asm
@@ -51,7 +51,7 @@
orr r8, r8, r10 ; differences of all 4 pixels
; calculate total sum
add r4, r4, r6 ; add positive differences to sum
- sub r4, r4, r7 ; substract negative differences from sum
+ sub r4, r4, r7 ; subtract negative differences from sum
; calculate sse
uxtb16 r7, r8 ; byte (two pixels) to halfwords
@@ -77,7 +77,7 @@
; calculate total sum
add r4, r4, r6 ; add positive differences to sum
- sub r4, r4, r7 ; substract negative differences from sum
+ sub r4, r4, r7 ; subtract negative differences from sum
; calculate sse
uxtb16 r7, r8 ; byte (two pixels) to halfwords
diff --git a/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_h_armv6.asm b/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_h_armv6.asm
index dd2ce68..3668dc5 100644
--- a/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_h_armv6.asm
+++ b/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_h_armv6.asm
@@ -58,7 +58,7 @@
orr r6, r6, r7 ; differences of all 4 pixels
; calculate total sum
adds r8, r8, r4 ; add positive differences to sum
- subs r8, r8, r5 ; substract negative differences from sum
+ subs r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -89,7 +89,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -120,7 +120,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -153,7 +153,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
diff --git a/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_hv_armv6.asm b/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_hv_armv6.asm
index f972d9b..b4e0959 100644
--- a/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_hv_armv6.asm
+++ b/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_hv_armv6.asm
@@ -69,7 +69,7 @@
orr r6, r6, r7 ; differences of all 4 pixels
; calculate total sum
adds r8, r8, r4 ; add positive differences to sum
- subs r8, r8, r5 ; substract negative differences from sum
+ subs r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -111,7 +111,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -153,7 +153,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -195,7 +195,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
diff --git a/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_v_armv6.asm b/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_v_armv6.asm
index f5da9c0..10863e2 100644
--- a/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_v_armv6.asm
+++ b/vp8/common/arm/armv6/vp8_variance_halfpixvar16x16_v_armv6.asm
@@ -59,7 +59,7 @@
orr r6, r6, r7 ; differences of all 4 pixels
; calculate total sum
adds r8, r8, r4 ; add positive differences to sum
- subs r8, r8, r5 ; substract negative differences from sum
+ subs r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -90,7 +90,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -121,7 +121,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
@@ -154,7 +154,7 @@
; calculate total sum
add r8, r8, r4 ; add positive differences to sum
- sub r8, r8, r5 ; substract negative differences from sum
+ sub r8, r8, r5 ; subtract negative differences from sum
; calculate sse
uxtb16 r5, r6 ; byte (two pixels) to halfwords
diff --git a/vp8/common/x86/loopfilter_mmx.asm b/vp8/common/x86/loopfilter_mmx.asm
index f388d24..88a07b9 100644
--- a/vp8/common/x86/loopfilter_mmx.asm
+++ b/vp8/common/x86/loopfilter_mmx.asm
@@ -527,7 +527,7 @@
pxor mm7, [GLOBAL(t80)] ; unoffset
; mm7 = q1
- ; tranpose and write back
+ ; transpose and write back
; mm1 = 72 62 52 42 32 22 12 02
; mm6 = 73 63 53 43 33 23 13 03
; mm3 = 74 64 54 44 34 24 14 04
@@ -1289,7 +1289,7 @@
pxor mm6, [GLOBAL(t80)] ; mm6 = 71 61 51 41 31 21 11 01
pxor mm3, [GLOBAL(t80)] ; mm3 = 76 66 56 46 36 26 15 06
- ; tranpose and write back
+ ; transpose and write back
movq mm0, [rdx] ; mm0 = 70 60 50 40 30 20 10 00
movq mm1, mm0 ; mm0 = 70 60 50 40 30 20 10 00
diff --git a/vp8/common/x86/loopfilter_sse2.asm b/vp8/common/x86/loopfilter_sse2.asm
index a66753b..1913abc 100644
--- a/vp8/common/x86/loopfilter_sse2.asm
+++ b/vp8/common/x86/loopfilter_sse2.asm
@@ -958,7 +958,7 @@
; start work on filters
B_FILTER 2
- ; tranpose and write back - only work on q1, q0, p0, p1
+ ; transpose and write back - only work on q1, q0, p0, p1
BV_TRANSPOSE
; store 16-line result
@@ -1023,7 +1023,7 @@
; start work on filters
B_FILTER 2
- ; tranpose and write back - only work on q1, q0, p0, p1
+ ; transpose and write back - only work on q1, q0, p0, p1
BV_TRANSPOSE
lea rdi, [rsi + rax] ; rdi points to row +1 for indirect addressing
diff --git a/vp8/encoder/firstpass.c b/vp8/encoder/firstpass.c
index afcda9f..98e5a71 100644
--- a/vp8/encoder/firstpass.c
+++ b/vp8/encoder/firstpass.c
@@ -2444,10 +2444,10 @@
find_next_key_frame(cpi, &this_frame_copy);
/* Special case: Error error_resilient_mode mode does not make much
- * sense for two pass but with its current meaning but this code is
+ * sense for two pass but with its current meaning this code is
* designed to stop outlandish behaviour if someone does set it when
* using two pass. It effectively disables GF groups. This is
- * temporary code till we decide what should really happen in this
+ * temporary code until we decide what should really happen in this
* case.
*/
if (cpi->oxcf.error_resilient_mode)
@@ -2773,7 +2773,7 @@
kf_group_intra_err += this_frame->intra_error;
kf_group_coded_err += this_frame->coded_error;
- /* load a the next frame's stats */
+ /* Load the next frame's stats. */
vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
input_stats(cpi, this_frame);
diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c
index 07138ec..7f39646 100644
--- a/vp8/encoder/onyx_if.c
+++ b/vp8/encoder/onyx_if.c
@@ -2681,8 +2681,8 @@
VP8_COMMON *cm = &cpi->common;
/* Do we need to apply resampling for one pass cbr.
- * In one pass this is more limited than in two pass cbr
- * The test and any change is only made one per key frame sequence
+ * In one pass this is more limited than in two pass cbr.
+ * The test and any change is only made once per key frame sequence.
*/
if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
{
@@ -2705,7 +2705,7 @@
cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
}
- /* Get the new hieght and width */
+ /* Get the new height and width */
Scale2Ratio(cm->horiz_scale, &hr, &hs);
Scale2Ratio(cm->vert_scale, &vr, &vs);
new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
diff --git a/vp9/common/arm/neon/vp9_idct32x32_add_neon.asm b/vp9/common/arm/neon/vp9_idct32x32_add_neon.asm
index 388a7d7..72e933e 100644
--- a/vp9/common/arm/neon/vp9_idct32x32_add_neon.asm
+++ b/vp9/common/arm/neon/vp9_idct32x32_add_neon.asm
@@ -72,7 +72,7 @@
; reg1 = output[first_offset]
; reg2 = output[second_offset]
; for proper address calculation, the last offset used when manipulating
- ; output, wethere reading or storing) must be passed in. use 0 for first
+ ; output, whether reading or storing) must be passed in. use 0 for first
; use.
MACRO
LOAD_FROM_OUTPUT $prev_offset, $first_offset, $second_offset, $reg1, $reg2
@@ -88,7 +88,7 @@
; output[first_offset] = reg1
; output[second_offset] = reg2
; for proper address calculation, the last offset used when manipulating
- ; output, wethere reading or storing) must be passed in. use 0 for first
+ ; output, whether reading or storing) must be passed in. use 0 for first
; use.
MACRO
STORE_IN_OUTPUT $prev_offset, $first_offset, $second_offset, $reg1, $reg2
@@ -242,7 +242,7 @@
; TODO(cd): have special case to re-use constants when they are similar for
; consecutive butterflies
; TODO(cd): have special case when both constants are the same, do the
- ; additions/substractions before the multiplies.
+ ; additions/subtractions before the multiplies.
; generate the constants
; generate scalar constants
mov r8, #$first_constant & 0xFF00
@@ -260,7 +260,7 @@
vmull.s16 q11, $regB, d31
vmull.s16 q12, $regC, d31
; (used) five for intermediate (q8-q12), one for constants (q15)
- ; do some addition/substractions (to get back two register)
+ ; do some addition/subtractions (to get back two register)
vsub.s32 q8, q8, q10
vsub.s32 q9, q9, q11
; do more multiplications (ordered for maximum latency hiding)
@@ -268,7 +268,7 @@
vmull.s16 q11, $regA, d30
vmull.s16 q15, $regB, d30
; (used) six for intermediate (q8-q12, q15)
- ; do more addition/substractions
+ ; do more addition/subtractions
vadd.s32 q11, q12, q11
vadd.s32 q10, q10, q15
; (used) four for intermediate (q8-q11)
diff --git a/vp9/common/arm/neon/vp9_reconintra_neon.asm b/vp9/common/arm/neon/vp9_reconintra_neon.asm
index 4a49964..dc9856f 100644
--- a/vp9/common/arm/neon/vp9_reconintra_neon.asm
+++ b/vp9/common/arm/neon/vp9_reconintra_neon.asm
@@ -315,8 +315,8 @@
vdup.u16 q2, r2
vadd.s16 q1, q1, q3
vadd.s16 q2, q2, q3
- vqshrun.s16 d0, q1, #0
- vqshrun.s16 d1, q2, #0
+ vqmovun.s16 d0, q1
+ vqmovun.s16 d1, q2
vst1.32 {d0[0]}, [r0], r1
vst1.32 {d1[0]}, [r0], r1
@@ -327,8 +327,8 @@
vdup.u16 q2, r2
vadd.s16 q1, q1, q3
vadd.s16 q2, q2, q3
- vqshrun.s16 d0, q1, #0
- vqshrun.s16 d1, q2, #0
+ vqmovun.s16 d0, q1
+ vqmovun.s16 d1, q2
vst1.32 {d0[0]}, [r0], r1
vst1.32 {d1[0]}, [r0], r1
bx lr
@@ -372,10 +372,10 @@
vadd.s16 q8, q3, q8
vadd.s16 q9, q3, q9
- vqshrun.s16 d0, q0, #0
- vqshrun.s16 d1, q1, #0
- vqshrun.s16 d2, q8, #0
- vqshrun.s16 d3, q9, #0
+ vqmovun.s16 d0, q0
+ vqmovun.s16 d1, q1
+ vqmovun.s16 d2, q8
+ vqmovun.s16 d3, q9
vst1.64 {d0}, [r0], r1
vst1.64 {d1}, [r0], r1
@@ -394,10 +394,10 @@
vadd.s16 q8, q3, q8
vadd.s16 q9, q3, q9
- vqshrun.s16 d0, q0, #0
- vqshrun.s16 d1, q1, #0
- vqshrun.s16 d2, q8, #0
- vqshrun.s16 d3, q9, #0
+ vqmovun.s16 d0, q0
+ vqmovun.s16 d1, q1
+ vqmovun.s16 d2, q8
+ vqmovun.s16 d3, q9
vst1.64 {d0}, [r0], r1
vst1.64 {d1}, [r0], r1
@@ -445,10 +445,10 @@
vadd.s16 q0, q0, q3
vadd.s16 q11, q8, q2
vadd.s16 q8, q8, q3
- vqshrun.s16 d2, q1, #0
- vqshrun.s16 d3, q0, #0
- vqshrun.s16 d22, q11, #0
- vqshrun.s16 d23, q8, #0
+ vqmovun.s16 d2, q1
+ vqmovun.s16 d3, q0
+ vqmovun.s16 d22, q11
+ vqmovun.s16 d23, q8
vdup.16 q0, d20[2] ; proload next 2 rows data
vdup.16 q8, d20[3]
vst1.64 {d2,d3}, [r0], r1
@@ -459,10 +459,10 @@
vadd.s16 q0, q0, q3
vadd.s16 q11, q8, q2
vadd.s16 q8, q8, q3
- vqshrun.s16 d2, q1, #0
- vqshrun.s16 d3, q0, #0
- vqshrun.s16 d22, q11, #0
- vqshrun.s16 d23, q8, #0
+ vqmovun.s16 d2, q1
+ vqmovun.s16 d3, q0
+ vqmovun.s16 d22, q11
+ vqmovun.s16 d23, q8
vdup.16 q0, d21[0] ; proload next 2 rows data
vdup.16 q8, d21[1]
vst1.64 {d2,d3}, [r0], r1
@@ -472,10 +472,10 @@
vadd.s16 q0, q0, q3
vadd.s16 q11, q8, q2
vadd.s16 q8, q8, q3
- vqshrun.s16 d2, q1, #0
- vqshrun.s16 d3, q0, #0
- vqshrun.s16 d22, q11, #0
- vqshrun.s16 d23, q8, #0
+ vqmovun.s16 d2, q1
+ vqmovun.s16 d3, q0
+ vqmovun.s16 d22, q11
+ vqmovun.s16 d23, q8
vdup.16 q0, d21[2] ; proload next 2 rows data
vdup.16 q8, d21[3]
vst1.64 {d2,d3}, [r0], r1
@@ -486,12 +486,10 @@
vadd.s16 q0, q0, q3
vadd.s16 q11, q8, q2
vadd.s16 q8, q8, q3
- vqshrun.s16 d2, q1, #0
- vqshrun.s16 d3, q0, #0
- vqshrun.s16 d22, q11, #0
- vqshrun.s16 d23, q8, #0
- vdup.16 q0, d20[2]
- vdup.16 q8, d20[3]
+ vqmovun.s16 d2, q1
+ vqmovun.s16 d3, q0
+ vqmovun.s16 d22, q11
+ vqmovun.s16 d23, q8
vld1.8 {d18}, [r3]! ; preload 8 left into r12
vmovl.u8 q10, d18
vst1.64 {d2,d3}, [r0], r1
@@ -544,19 +542,19 @@
vadd.s16 q13, q0, q9
vadd.s16 q14, q0, q10
vadd.s16 q15, q0, q11
- vqshrun.s16 d0, q12, #0
- vqshrun.s16 d1, q13, #0
+ vqmovun.s16 d0, q12
+ vqmovun.s16 d1, q13
vadd.s16 q12, q2, q8
vadd.s16 q13, q2, q9
- vqshrun.s16 d2, q14, #0
- vqshrun.s16 d3, q15, #0
+ vqmovun.s16 d2, q14
+ vqmovun.s16 d3, q15
vadd.s16 q14, q2, q10
vadd.s16 q15, q2, q11
vst1.64 {d0-d3}, [r0], r1
- vqshrun.s16 d24, q12, #0
- vqshrun.s16 d25, q13, #0
- vqshrun.s16 d26, q14, #0
- vqshrun.s16 d27, q15, #0
+ vqmovun.s16 d24, q12
+ vqmovun.s16 d25, q13
+ vqmovun.s16 d26, q14
+ vqmovun.s16 d27, q15
vdup.16 q1, d6[2]
vdup.16 q2, d6[3]
vst1.64 {d24-d27}, [r0], r1
@@ -566,19 +564,19 @@
vadd.s16 q13, q1, q9
vadd.s16 q14, q1, q10
vadd.s16 q15, q1, q11
- vqshrun.s16 d0, q12, #0
- vqshrun.s16 d1, q13, #0
+ vqmovun.s16 d0, q12
+ vqmovun.s16 d1, q13
vadd.s16 q12, q2, q8
vadd.s16 q13, q2, q9
- vqshrun.s16 d2, q14, #0
- vqshrun.s16 d3, q15, #0
+ vqmovun.s16 d2, q14
+ vqmovun.s16 d3, q15
vadd.s16 q14, q2, q10
vadd.s16 q15, q2, q11
vst1.64 {d0-d3}, [r0], r1
- vqshrun.s16 d24, q12, #0
- vqshrun.s16 d25, q13, #0
- vqshrun.s16 d26, q14, #0
- vqshrun.s16 d27, q15, #0
+ vqmovun.s16 d24, q12
+ vqmovun.s16 d25, q13
+ vqmovun.s16 d26, q14
+ vqmovun.s16 d27, q15
vdup.16 q0, d7[0]
vdup.16 q2, d7[1]
vst1.64 {d24-d27}, [r0], r1
@@ -588,19 +586,19 @@
vadd.s16 q13, q0, q9
vadd.s16 q14, q0, q10
vadd.s16 q15, q0, q11
- vqshrun.s16 d0, q12, #0
- vqshrun.s16 d1, q13, #0
+ vqmovun.s16 d0, q12
+ vqmovun.s16 d1, q13
vadd.s16 q12, q2, q8
vadd.s16 q13, q2, q9
- vqshrun.s16 d2, q14, #0
- vqshrun.s16 d3, q15, #0
+ vqmovun.s16 d2, q14
+ vqmovun.s16 d3, q15
vadd.s16 q14, q2, q10
vadd.s16 q15, q2, q11
vst1.64 {d0-d3}, [r0], r1
- vqshrun.s16 d24, q12, #0
- vqshrun.s16 d25, q13, #0
- vqshrun.s16 d26, q14, #0
- vqshrun.s16 d27, q15, #0
+ vqmovun.s16 d24, q12
+ vqmovun.s16 d25, q13
+ vqmovun.s16 d26, q14
+ vqmovun.s16 d27, q15
vdup.16 q0, d7[2]
vdup.16 q2, d7[3]
vst1.64 {d24-d27}, [r0], r1
@@ -610,20 +608,20 @@
vadd.s16 q13, q0, q9
vadd.s16 q14, q0, q10
vadd.s16 q15, q0, q11
- vqshrun.s16 d0, q12, #0
- vqshrun.s16 d1, q13, #0
+ vqmovun.s16 d0, q12
+ vqmovun.s16 d1, q13
vadd.s16 q12, q2, q8
vadd.s16 q13, q2, q9
- vqshrun.s16 d2, q14, #0
- vqshrun.s16 d3, q15, #0
+ vqmovun.s16 d2, q14
+ vqmovun.s16 d3, q15
vadd.s16 q14, q2, q10
vadd.s16 q15, q2, q11
vst1.64 {d0-d3}, [r0], r1
- vqshrun.s16 d24, q12, #0
- vqshrun.s16 d25, q13, #0
+ vqmovun.s16 d24, q12
+ vqmovun.s16 d25, q13
vld1.8 {d0}, [r3]! ; preload 8 left pixels
- vqshrun.s16 d26, q14, #0
- vqshrun.s16 d27, q15, #0
+ vqmovun.s16 d26, q14
+ vqmovun.s16 d27, q15
vmovl.u8 q3, d0
vst1.64 {d24-d27}, [r0], r1
diff --git a/vp9/common/vp9_filter.c b/vp9/common/vp9_filter.c
index 546f603..7474a88 100644
--- a/vp9/common/vp9_filter.c
+++ b/vp9/common/vp9_filter.c
@@ -10,12 +10,9 @@
#include <assert.h>
-#include "vpx_ports/mem.h"
-
#include "vp9/common/vp9_filter.h"
-DECLARE_ALIGNED(256, const InterpKernel,
- vp9_bilinear_filters[SUBPEL_SHIFTS]) = {
+const InterpKernel vp9_bilinear_filters[SUBPEL_SHIFTS] = {
{ 0, 0, 0, 128, 0, 0, 0, 0 },
{ 0, 0, 0, 120, 8, 0, 0, 0 },
{ 0, 0, 0, 112, 16, 0, 0, 0 },
@@ -35,8 +32,7 @@
};
// Lagrangian interpolation filter
-DECLARE_ALIGNED(256, const InterpKernel,
- vp9_sub_pel_filters_8[SUBPEL_SHIFTS]) = {
+const InterpKernel vp9_sub_pel_filters_8[SUBPEL_SHIFTS] = {
{ 0, 0, 0, 128, 0, 0, 0, 0},
{ 0, 1, -5, 126, 8, -3, 1, 0},
{ -1, 3, -10, 122, 18, -6, 2, 0},
@@ -56,8 +52,7 @@
};
// DCT based filter
-DECLARE_ALIGNED(256, const InterpKernel,
- vp9_sub_pel_filters_8s[SUBPEL_SHIFTS]) = {
+const InterpKernel vp9_sub_pel_filters_8s[SUBPEL_SHIFTS] = {
{0, 0, 0, 128, 0, 0, 0, 0},
{-1, 3, -7, 127, 8, -3, 1, 0},
{-2, 5, -13, 125, 17, -6, 3, -1},
@@ -77,8 +72,7 @@
};
// freqmultiplier = 0.5
-DECLARE_ALIGNED(256, const InterpKernel,
- vp9_sub_pel_filters_8lp[SUBPEL_SHIFTS]) = {
+const InterpKernel vp9_sub_pel_filters_8lp[SUBPEL_SHIFTS] = {
{ 0, 0, 0, 128, 0, 0, 0, 0},
{-3, -1, 32, 64, 38, 1, -3, 0},
{-2, -2, 29, 63, 41, 2, -3, 0},
diff --git a/vp9/common/vp9_filter.h b/vp9/common/vp9_filter.h
index 15610d7..29d3867 100644
--- a/vp9/common/vp9_filter.h
+++ b/vp9/common/vp9_filter.h
@@ -13,6 +13,8 @@
#include "./vpx_config.h"
#include "vpx/vpx_integer.h"
+#include "vpx_ports/mem.h"
+
#ifdef __cplusplus
extern "C" {
@@ -37,10 +39,14 @@
const InterpKernel *vp9_get_interp_kernel(INTERP_FILTER filter);
-extern const InterpKernel vp9_bilinear_filters[SUBPEL_SHIFTS];
-extern const InterpKernel vp9_sub_pel_filters_8[SUBPEL_SHIFTS];
-extern const InterpKernel vp9_sub_pel_filters_8s[SUBPEL_SHIFTS];
-extern const InterpKernel vp9_sub_pel_filters_8lp[SUBPEL_SHIFTS];
+DECLARE_ALIGNED(256, extern const InterpKernel,
+ vp9_bilinear_filters[SUBPEL_SHIFTS]);
+DECLARE_ALIGNED(256, extern const InterpKernel,
+ vp9_sub_pel_filters_8[SUBPEL_SHIFTS]);
+DECLARE_ALIGNED(256, extern const InterpKernel,
+ vp9_sub_pel_filters_8s[SUBPEL_SHIFTS]);
+DECLARE_ALIGNED(256, extern const InterpKernel,
+ vp9_sub_pel_filters_8lp[SUBPEL_SHIFTS]);
// The VP9_BILINEAR_FILTERS_2TAP macro returns a pointer to the bilinear
// filter kernel as a 2 tap filter.
diff --git a/vp9/common/vp9_reconinter.c b/vp9/common/vp9_reconinter.c
index 7576e7b..df603ad 100644
--- a/vp9/common/vp9_reconinter.c
+++ b/vp9/common/vp9_reconinter.c
@@ -139,9 +139,6 @@
return clamped_mv;
}
-// TODO(jkoleszar): In principle, pred_w, pred_h are unnecessary, as we could
-// calculate the subsampled BLOCK_SIZE, but that type isn't defined for
-// sizes smaller than 16x16 yet.
static void build_inter_predictors(MACROBLOCKD *xd, int plane, int block,
int bw, int bh,
int x, int y, int w, int h,
diff --git a/vp9/common/vp9_rtcd_defs.sh b/vp9/common/vp9_rtcd_defs.sh
index 6317103..a18ae9b 100644
--- a/vp9/common/vp9_rtcd_defs.sh
+++ b/vp9/common/vp9_rtcd_defs.sh
@@ -386,7 +386,7 @@
specialize vp9_variance4x4 mmx $sse2_x86inc
prototype unsigned int vp9_sub_pixel_variance64x64 "const uint8_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse"
-specialize vp9_sub_pixel_variance64x64 $sse2_x86inc $ssse3_x86inc
+specialize vp9_sub_pixel_variance64x64 $sse2_x86inc $ssse3_x86inc avx2
prototype unsigned int vp9_sub_pixel_avg_variance64x64 "const uint8_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, const uint8_t *second_pred"
specialize vp9_sub_pixel_avg_variance64x64 $sse2_x86inc $ssse3_x86inc
@@ -416,7 +416,7 @@
specialize vp9_sub_pixel_avg_variance16x32 $sse2_x86inc $ssse3_x86inc
prototype unsigned int vp9_sub_pixel_variance32x32 "const uint8_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse"
-specialize vp9_sub_pixel_variance32x32 $sse2_x86inc $ssse3_x86inc
+specialize vp9_sub_pixel_variance32x32 $sse2_x86inc $ssse3_x86inc avx2
prototype unsigned int vp9_sub_pixel_avg_variance32x32 "const uint8_t *src_ptr, int source_stride, int xoffset, int yoffset, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, const uint8_t *second_pred"
specialize vp9_sub_pixel_avg_variance32x32 $sse2_x86inc $ssse3_x86inc
diff --git a/vp9/common/x86/vp9_asm_stubs.c b/vp9/common/x86/vp9_asm_stubs.c
index a2cf910..1b4904c 100644
--- a/vp9/common/x86/vp9_asm_stubs.c
+++ b/vp9/common/x86/vp9_asm_stubs.c
@@ -142,20 +142,29 @@
#if HAVE_AVX2
filter8_1dfunction vp9_filter_block1d16_v8_avx2;
filter8_1dfunction vp9_filter_block1d16_h8_avx2;
+filter8_1dfunction vp9_filter_block1d4_v8_ssse3;
+#if (ARCH_X86_64)
+filter8_1dfunction vp9_filter_block1d8_v8_intrin_ssse3;
+filter8_1dfunction vp9_filter_block1d8_h8_intrin_ssse3;
+filter8_1dfunction vp9_filter_block1d4_h8_intrin_ssse3;
+#define vp9_filter_block1d8_v8_avx2 vp9_filter_block1d8_v8_intrin_ssse3
+#define vp9_filter_block1d8_h8_avx2 vp9_filter_block1d8_h8_intrin_ssse3
+#define vp9_filter_block1d4_h8_avx2 vp9_filter_block1d4_h8_intrin_ssse3
+#else
filter8_1dfunction vp9_filter_block1d8_v8_ssse3;
filter8_1dfunction vp9_filter_block1d8_h8_ssse3;
-filter8_1dfunction vp9_filter_block1d4_v8_ssse3;
filter8_1dfunction vp9_filter_block1d4_h8_ssse3;
+#define vp9_filter_block1d8_v8_avx2 vp9_filter_block1d8_v8_ssse3
+#define vp9_filter_block1d8_h8_avx2 vp9_filter_block1d8_h8_ssse3
+#define vp9_filter_block1d4_h8_avx2 vp9_filter_block1d4_h8_ssse3
+#endif
filter8_1dfunction vp9_filter_block1d16_v2_ssse3;
filter8_1dfunction vp9_filter_block1d16_h2_ssse3;
filter8_1dfunction vp9_filter_block1d8_v2_ssse3;
filter8_1dfunction vp9_filter_block1d8_h2_ssse3;
filter8_1dfunction vp9_filter_block1d4_v2_ssse3;
filter8_1dfunction vp9_filter_block1d4_h2_ssse3;
-#define vp9_filter_block1d8_v8_avx2 vp9_filter_block1d8_v8_ssse3
-#define vp9_filter_block1d8_h8_avx2 vp9_filter_block1d8_h8_ssse3
#define vp9_filter_block1d4_v8_avx2 vp9_filter_block1d4_v8_ssse3
-#define vp9_filter_block1d4_h8_avx2 vp9_filter_block1d4_h8_ssse3
#define vp9_filter_block1d16_v2_avx2 vp9_filter_block1d16_v2_ssse3
#define vp9_filter_block1d16_h2_avx2 vp9_filter_block1d16_h2_ssse3
#define vp9_filter_block1d8_v2_avx2 vp9_filter_block1d8_v2_ssse3
@@ -183,12 +192,26 @@
FUN_CONV_2D(, avx2);
#endif
#if HAVE_SSSE3
+#if (ARCH_X86_64)
+filter8_1dfunction vp9_filter_block1d16_v8_intrin_ssse3;
+filter8_1dfunction vp9_filter_block1d16_h8_intrin_ssse3;
+filter8_1dfunction vp9_filter_block1d8_v8_intrin_ssse3;
+filter8_1dfunction vp9_filter_block1d8_h8_intrin_ssse3;
+filter8_1dfunction vp9_filter_block1d4_v8_ssse3;
+filter8_1dfunction vp9_filter_block1d4_h8_intrin_ssse3;
+#define vp9_filter_block1d16_v8_ssse3 vp9_filter_block1d16_v8_intrin_ssse3
+#define vp9_filter_block1d16_h8_ssse3 vp9_filter_block1d16_h8_intrin_ssse3
+#define vp9_filter_block1d8_v8_ssse3 vp9_filter_block1d8_v8_intrin_ssse3
+#define vp9_filter_block1d8_h8_ssse3 vp9_filter_block1d8_h8_intrin_ssse3
+#define vp9_filter_block1d4_h8_ssse3 vp9_filter_block1d4_h8_intrin_ssse3
+#else
filter8_1dfunction vp9_filter_block1d16_v8_ssse3;
filter8_1dfunction vp9_filter_block1d16_h8_ssse3;
filter8_1dfunction vp9_filter_block1d8_v8_ssse3;
filter8_1dfunction vp9_filter_block1d8_h8_ssse3;
filter8_1dfunction vp9_filter_block1d4_v8_ssse3;
filter8_1dfunction vp9_filter_block1d4_h8_ssse3;
+#endif
filter8_1dfunction vp9_filter_block1d16_v8_avg_ssse3;
filter8_1dfunction vp9_filter_block1d16_h8_avg_ssse3;
filter8_1dfunction vp9_filter_block1d8_v8_avg_ssse3;
diff --git a/vp9/common/x86/vp9_loopfilter_mmx.asm b/vp9/common/x86/vp9_loopfilter_mmx.asm
index a7f6930..91055b9 100644
--- a/vp9/common/x86/vp9_loopfilter_mmx.asm
+++ b/vp9/common/x86/vp9_loopfilter_mmx.asm
@@ -527,7 +527,7 @@
pxor mm7, [GLOBAL(t80)] ; unoffset
; mm7 = q1
- ; tranpose and write back
+ ; transpose and write back
; mm1 = 72 62 52 42 32 22 12 02
; mm6 = 73 63 53 43 33 23 13 03
; mm3 = 74 64 54 44 34 24 14 04
diff --git a/vp9/common/x86/vp9_subpixel_8t_intrin_ssse3.c b/vp9/common/x86/vp9_subpixel_8t_intrin_ssse3.c
new file mode 100644
index 0000000..dbea141
--- /dev/null
+++ b/vp9/common/x86/vp9_subpixel_8t_intrin_ssse3.c
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE 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.
+ */
+
+#include <tmmintrin.h>
+#include "vpx_ports/mem.h"
+#include "vpx_ports/emmintrin_compat.h"
+
+// filters only for the 4_h8 convolution
+DECLARE_ALIGNED(16, const unsigned char, filt1_4_h8[16])= {
+ 0, 1, 1, 2, 2, 3, 3, 4, 2, 3, 3, 4, 4, 5, 5, 6};
+
+DECLARE_ALIGNED(16, const unsigned char, filt2_4_h8[16])= {
+ 4, 5, 5, 6, 6, 7, 7, 8, 6, 7, 7, 8, 8, 9, 9, 10};
+
+// filters for 8_h8 and 16_h8
+DECLARE_ALIGNED(16, const unsigned char, filt1_global[16])= {
+ 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8};
+
+DECLARE_ALIGNED(16, const unsigned char, filt2_global[16])= {
+ 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10};
+
+DECLARE_ALIGNED(16, const unsigned char, filt3_global[16])= {
+ 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12};
+
+DECLARE_ALIGNED(16, const unsigned char, filt4_global[16])= {
+ 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14};
+
+void vp9_filter_block1d4_h8_intrin_ssse3(unsigned char *src_ptr,
+ unsigned int src_pixels_per_line,
+ unsigned char *output_ptr,
+ unsigned int output_pitch,
+ unsigned int output_height,
+ int16_t *filter) {
+ __m128i firstFilters, secondFilters, thirdFilters, forthFilters;
+ __m128i srcRegFilt1, srcRegFilt2, srcRegFilt3, srcRegFilt4;
+ __m128i addFilterReg64, filtersReg, srcReg, minReg;
+ unsigned int i;
+
+ // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
+ addFilterReg64 =_mm_set1_epi32((int)0x0400040u);
+ filtersReg = _mm_loadu_si128((__m128i *)filter);
+ // converting the 16 bit (short) to 8 bit (byte) and have the same data
+ // in both lanes of 128 bit register.
+ filtersReg =_mm_packs_epi16(filtersReg, filtersReg);
+
+ // duplicate only the first 16 bits in the filter into the first lane
+ firstFilters = _mm_shufflelo_epi16(filtersReg, 0);
+ // duplicate only the third 16 bit in the filter into the first lane
+ secondFilters = _mm_shufflelo_epi16(filtersReg, 0xAAu);
+ // duplicate only the seconds 16 bits in the filter into the second lane
+ firstFilters = _mm_shufflehi_epi16(firstFilters, 0x55u);
+ // duplicate only the forth 16 bits in the filter into the second lane
+ secondFilters = _mm_shufflehi_epi16(secondFilters, 0xFFu);
+
+ // loading the local filters
+ thirdFilters =_mm_load_si128((__m128i const *)filt1_4_h8);
+ forthFilters = _mm_load_si128((__m128i const *)filt2_4_h8);
+
+ for (i = 0; i < output_height; i++) {
+ srcReg = _mm_loadu_si128((__m128i *)(src_ptr-3));
+
+ // filter the source buffer
+ srcRegFilt1= _mm_shuffle_epi8(srcReg, thirdFilters);
+ srcRegFilt2= _mm_shuffle_epi8(srcReg, forthFilters);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt1 = _mm_maddubs_epi16(srcRegFilt1, firstFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, secondFilters);
+
+ // extract the higher half of the lane
+ srcRegFilt3 = _mm_srli_si128(srcRegFilt1, 8);
+ srcRegFilt4 = _mm_srli_si128(srcRegFilt2, 8);
+
+ minReg = _mm_min_epi16(srcRegFilt3, srcRegFilt2);
+
+ // add and saturate all the results together
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt4);
+ srcRegFilt3 = _mm_max_epi16(srcRegFilt3, srcRegFilt2);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, minReg);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt3);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, addFilterReg64);
+
+ // shift by 7 bit each 16 bits
+ srcRegFilt1 = _mm_srai_epi16(srcRegFilt1, 7);
+
+ // shrink to 8 bit each 16 bits
+ srcRegFilt1 = _mm_packus_epi16(srcRegFilt1, srcRegFilt1);
+ src_ptr+=src_pixels_per_line;
+
+ // save only 4 bytes
+ *((int*)&output_ptr[0])= _mm_cvtsi128_si32(srcRegFilt1);
+
+ output_ptr+=output_pitch;
+ }
+}
+
+void vp9_filter_block1d8_h8_intrin_ssse3(unsigned char *src_ptr,
+ unsigned int src_pixels_per_line,
+ unsigned char *output_ptr,
+ unsigned int output_pitch,
+ unsigned int output_height,
+ int16_t *filter) {
+ __m128i firstFilters, secondFilters, thirdFilters, forthFilters, srcReg;
+ __m128i filt1Reg, filt2Reg, filt3Reg, filt4Reg;
+ __m128i srcRegFilt1, srcRegFilt2, srcRegFilt3, srcRegFilt4;
+ __m128i addFilterReg64, filtersReg, minReg;
+ unsigned int i;
+
+ // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
+ addFilterReg64 = _mm_set1_epi32((int)0x0400040u);
+ filtersReg = _mm_loadu_si128((__m128i *)filter);
+ // converting the 16 bit (short) to 8 bit (byte) and have the same data
+ // in both lanes of 128 bit register.
+ filtersReg =_mm_packs_epi16(filtersReg, filtersReg);
+
+ // duplicate only the first 16 bits (first and second byte)
+ // across 128 bit register
+ firstFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x100u));
+ // duplicate only the second 16 bits (third and forth byte)
+ // across 128 bit register
+ secondFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x302u));
+ // duplicate only the third 16 bits (fifth and sixth byte)
+ // across 128 bit register
+ thirdFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x504u));
+ // duplicate only the forth 16 bits (seventh and eighth byte)
+ // across 128 bit register
+ forthFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x706u));
+
+ filt1Reg = _mm_load_si128((__m128i const *)filt1_global);
+ filt2Reg = _mm_load_si128((__m128i const *)filt2_global);
+ filt3Reg = _mm_load_si128((__m128i const *)filt3_global);
+ filt4Reg = _mm_load_si128((__m128i const *)filt4_global);
+
+ for (i = 0; i < output_height; i++) {
+ srcReg = _mm_loadu_si128((__m128i *)(src_ptr-3));
+
+ // filter the source buffer
+ srcRegFilt1= _mm_shuffle_epi8(srcReg, filt1Reg);
+ srcRegFilt2= _mm_shuffle_epi8(srcReg, filt2Reg);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt1 = _mm_maddubs_epi16(srcRegFilt1, firstFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, secondFilters);
+
+ // filter the source buffer
+ srcRegFilt3= _mm_shuffle_epi8(srcReg, filt3Reg);
+ srcRegFilt4= _mm_shuffle_epi8(srcReg, filt4Reg);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt3 = _mm_maddubs_epi16(srcRegFilt3, thirdFilters);
+ srcRegFilt4 = _mm_maddubs_epi16(srcRegFilt4, forthFilters);
+
+ // add and saturate all the results together
+ minReg = _mm_min_epi16(srcRegFilt4, srcRegFilt3);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt2);
+
+ srcRegFilt4= _mm_max_epi16(srcRegFilt4, srcRegFilt3);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, minReg);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt4);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, addFilterReg64);
+
+ // shift by 7 bit each 16 bits
+ srcRegFilt1 = _mm_srai_epi16(srcRegFilt1, 7);
+
+ // shrink to 8 bit each 16 bits
+ srcRegFilt1 = _mm_packus_epi16(srcRegFilt1, srcRegFilt1);
+
+ src_ptr+=src_pixels_per_line;
+
+ // save only 8 bytes
+ _mm_storel_epi64((__m128i*)&output_ptr[0], srcRegFilt1);
+
+ output_ptr+=output_pitch;
+ }
+}
+
+void vp9_filter_block1d16_h8_intrin_ssse3(unsigned char *src_ptr,
+ unsigned int src_pixels_per_line,
+ unsigned char *output_ptr,
+ unsigned int output_pitch,
+ unsigned int output_height,
+ int16_t *filter) {
+ __m128i addFilterReg64, filtersReg, srcReg1, srcReg2;
+ __m128i filt1Reg, filt2Reg, filt3Reg, filt4Reg;
+ __m128i firstFilters, secondFilters, thirdFilters, forthFilters;
+ __m128i srcRegFilt1_1, srcRegFilt2_1, srcRegFilt2, srcRegFilt3;
+ unsigned int i;
+
+ // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
+ addFilterReg64 = _mm_set1_epi32((int)0x0400040u);
+ filtersReg = _mm_loadu_si128((__m128i *)filter);
+ // converting the 16 bit (short) to 8 bit (byte) and have the same data
+ // in both lanes of 128 bit register.
+ filtersReg =_mm_packs_epi16(filtersReg, filtersReg);
+
+ // duplicate only the first 16 bits (first and second byte)
+ // across 128 bit register
+ firstFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x100u));
+ // duplicate only the second 16 bits (third and forth byte)
+ // across 128 bit register
+ secondFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x302u));
+ // duplicate only the third 16 bits (fifth and sixth byte)
+ // across 128 bit register
+ thirdFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x504u));
+ // duplicate only the forth 16 bits (seventh and eighth byte)
+ // across 128 bit register
+ forthFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x706u));
+
+ filt1Reg = _mm_load_si128((__m128i const *)filt1_global);
+ filt2Reg = _mm_load_si128((__m128i const *)filt2_global);
+ filt3Reg = _mm_load_si128((__m128i const *)filt3_global);
+ filt4Reg = _mm_load_si128((__m128i const *)filt4_global);
+
+ for (i = 0; i < output_height; i++) {
+ srcReg1 = _mm_loadu_si128((__m128i *)(src_ptr-3));
+
+ // filter the source buffer
+ srcRegFilt1_1= _mm_shuffle_epi8(srcReg1, filt1Reg);
+ srcRegFilt2= _mm_shuffle_epi8(srcReg1, filt2Reg);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt1_1 = _mm_maddubs_epi16(srcRegFilt1_1, firstFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, secondFilters);
+
+ // add and saturate the results together
+ srcRegFilt1_1 = _mm_adds_epi16(srcRegFilt1_1, srcRegFilt2);
+
+ // filter the source buffer
+ srcRegFilt3= _mm_shuffle_epi8(srcReg1, filt4Reg);
+ srcRegFilt2= _mm_shuffle_epi8(srcReg1, filt3Reg);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt3 = _mm_maddubs_epi16(srcRegFilt3, forthFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, thirdFilters);
+
+ // add and saturate the results together
+ srcRegFilt1_1 = _mm_adds_epi16(srcRegFilt1_1,
+ _mm_min_epi16(srcRegFilt3, srcRegFilt2));
+
+ // reading the next 16 bytes.
+ // (part of it was being read by earlier read)
+ srcReg2 = _mm_loadu_si128((__m128i *)(src_ptr+5));
+
+ // add and saturate the results together
+ srcRegFilt1_1 = _mm_adds_epi16(srcRegFilt1_1,
+ _mm_max_epi16(srcRegFilt3, srcRegFilt2));
+
+ // filter the source buffer
+ srcRegFilt2_1= _mm_shuffle_epi8(srcReg2, filt1Reg);
+ srcRegFilt2= _mm_shuffle_epi8(srcReg2, filt2Reg);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt2_1 = _mm_maddubs_epi16(srcRegFilt2_1, firstFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, secondFilters);
+
+ // add and saturate the results together
+ srcRegFilt2_1 = _mm_adds_epi16(srcRegFilt2_1, srcRegFilt2);
+
+ // filter the source buffer
+ srcRegFilt3= _mm_shuffle_epi8(srcReg2, filt4Reg);
+ srcRegFilt2= _mm_shuffle_epi8(srcReg2, filt3Reg);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt3 = _mm_maddubs_epi16(srcRegFilt3, forthFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, thirdFilters);
+
+ // add and saturate the results together
+ srcRegFilt2_1 = _mm_adds_epi16(srcRegFilt2_1,
+ _mm_min_epi16(srcRegFilt3, srcRegFilt2));
+ srcRegFilt2_1 = _mm_adds_epi16(srcRegFilt2_1,
+ _mm_max_epi16(srcRegFilt3, srcRegFilt2));
+
+ srcRegFilt1_1 = _mm_adds_epi16(srcRegFilt1_1, addFilterReg64);
+ srcRegFilt2_1 = _mm_adds_epi16(srcRegFilt2_1, addFilterReg64);
+
+ // shift by 7 bit each 16 bit
+ srcRegFilt1_1 = _mm_srai_epi16(srcRegFilt1_1, 7);
+ srcRegFilt2_1 = _mm_srai_epi16(srcRegFilt2_1, 7);
+
+ // shrink to 8 bit each 16 bits, the first lane contain the first
+ // convolve result and the second lane contain the second convolve
+ // result
+ srcRegFilt1_1 = _mm_packus_epi16(srcRegFilt1_1, srcRegFilt2_1);
+
+ src_ptr+=src_pixels_per_line;
+
+ // save 16 bytes
+ _mm_store_si128((__m128i*)output_ptr, srcRegFilt1_1);
+
+ output_ptr+=output_pitch;
+ }
+}
+
+void vp9_filter_block1d8_v8_intrin_ssse3(unsigned char *src_ptr,
+ unsigned int src_pitch,
+ unsigned char *output_ptr,
+ unsigned int out_pitch,
+ unsigned int output_height,
+ int16_t *filter) {
+ __m128i addFilterReg64, filtersReg, minReg, srcRegFilt6;
+ __m128i firstFilters, secondFilters, thirdFilters, forthFilters;
+ __m128i srcRegFilt1, srcRegFilt2, srcRegFilt3, srcRegFilt4, srcRegFilt5;
+ unsigned int i;
+
+ // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
+ addFilterReg64 = _mm_set1_epi32((int)0x0400040u);
+ filtersReg = _mm_loadu_si128((__m128i *)filter);
+ // converting the 16 bit (short) to 8 bit (byte) and have the same data
+ // in both lanes of 128 bit register.
+ filtersReg =_mm_packs_epi16(filtersReg, filtersReg);
+
+ // duplicate only the first 16 bits in the filter
+ firstFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x100u));
+ // duplicate only the second 16 bits in the filter
+ secondFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x302u));
+ // duplicate only the third 16 bits in the filter
+ thirdFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x504u));
+ // duplicate only the forth 16 bits in the filter
+ forthFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x706u));
+
+ for (i = 0; i < output_height; i++) {
+ // load the first 8 bytes
+ srcRegFilt1 = _mm_loadl_epi64((__m128i *)&src_ptr[0]);
+ // load the next 8 bytes in stride of src_pitch
+ srcRegFilt2 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch)[0]);
+ srcRegFilt3 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch*2)[0]);
+ srcRegFilt4 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch*3)[0]);
+
+ // merge the result together
+ srcRegFilt1 = _mm_unpacklo_epi8(srcRegFilt1, srcRegFilt2);
+ srcRegFilt3 = _mm_unpacklo_epi8(srcRegFilt3, srcRegFilt4);
+
+ // load the next 8 bytes in stride of src_pitch
+ srcRegFilt2 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch*4)[0]);
+ srcRegFilt4 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch*5)[0]);
+ srcRegFilt5 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch*6)[0]);
+ srcRegFilt6 = _mm_loadl_epi64((__m128i *)&(src_ptr+src_pitch*7)[0]);
+
+ // merge the result together
+ srcRegFilt2 = _mm_unpacklo_epi8(srcRegFilt2, srcRegFilt4);
+ srcRegFilt5 = _mm_unpacklo_epi8(srcRegFilt5, srcRegFilt6);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt1 = _mm_maddubs_epi16(srcRegFilt1, firstFilters);
+ srcRegFilt3 = _mm_maddubs_epi16(srcRegFilt3, secondFilters);
+ srcRegFilt2 = _mm_maddubs_epi16(srcRegFilt2, thirdFilters);
+ srcRegFilt5 = _mm_maddubs_epi16(srcRegFilt5, forthFilters);
+
+ // add and saturate the results together
+ minReg = _mm_min_epi16(srcRegFilt2, srcRegFilt3);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt5);
+ srcRegFilt2 = _mm_max_epi16(srcRegFilt2, srcRegFilt3);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, minReg);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt2);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, addFilterReg64);
+
+ // shift by 7 bit each 16 bit
+ srcRegFilt1 = _mm_srai_epi16(srcRegFilt1, 7);
+
+ // shrink to 8 bit each 16 bits
+ srcRegFilt1 = _mm_packus_epi16(srcRegFilt1, srcRegFilt1);
+
+ src_ptr+=src_pitch;
+
+ // save only 8 bytes convolve result
+ _mm_storel_epi64((__m128i*)&output_ptr[0], srcRegFilt1);
+
+ output_ptr+=out_pitch;
+ }
+}
+
+void vp9_filter_block1d16_v8_intrin_ssse3(unsigned char *src_ptr,
+ unsigned int src_pitch,
+ unsigned char *output_ptr,
+ unsigned int out_pitch,
+ unsigned int output_height,
+ int16_t *filter) {
+ __m128i addFilterReg64, filtersReg, srcRegFilt1, srcRegFilt2, srcRegFilt3;
+ __m128i firstFilters, secondFilters, thirdFilters, forthFilters;
+ __m128i srcRegFilt4, srcRegFilt5, srcRegFilt6, srcRegFilt7, srcRegFilt8;
+ unsigned int i;
+
+ // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
+ addFilterReg64 = _mm_set1_epi32((int)0x0400040u);
+ filtersReg = _mm_loadu_si128((__m128i *)filter);
+ // converting the 16 bit (short) to 8 bit (byte) and have the same data
+ // in both lanes of 128 bit register.
+ filtersReg =_mm_packs_epi16(filtersReg, filtersReg);
+
+ // duplicate only the first 16 bits in the filter
+ firstFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x100u));
+ // duplicate only the second 16 bits in the filter
+ secondFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x302u));
+ // duplicate only the third 16 bits in the filter
+ thirdFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x504u));
+ // duplicate only the forth 16 bits in the filter
+ forthFilters = _mm_shuffle_epi8(filtersReg, _mm_set1_epi16(0x706u));
+
+ for (i = 0; i < output_height; i++) {
+ // load the first 16 bytes
+ srcRegFilt1 = _mm_loadu_si128((__m128i *)(src_ptr));
+ // load the next 16 bytes in stride of src_pitch
+ srcRegFilt2 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch));
+ srcRegFilt3 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch*6));
+ srcRegFilt4 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch*7));
+
+ // merge the result together
+ srcRegFilt5 = _mm_unpacklo_epi8(srcRegFilt1, srcRegFilt2);
+ srcRegFilt6 = _mm_unpacklo_epi8(srcRegFilt3, srcRegFilt4);
+ srcRegFilt1 = _mm_unpackhi_epi8(srcRegFilt1, srcRegFilt2);
+ srcRegFilt3 = _mm_unpackhi_epi8(srcRegFilt3, srcRegFilt4);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt5 = _mm_maddubs_epi16(srcRegFilt5, firstFilters);
+ srcRegFilt6 = _mm_maddubs_epi16(srcRegFilt6, forthFilters);
+ srcRegFilt1 = _mm_maddubs_epi16(srcRegFilt1, firstFilters);
+ srcRegFilt3 = _mm_maddubs_epi16(srcRegFilt3, forthFilters);
+
+ // add and saturate the results together
+ srcRegFilt5 = _mm_adds_epi16(srcRegFilt5, srcRegFilt6);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt3);
+
+ // load the next 16 bytes in stride of two/three src_pitch
+ srcRegFilt2 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch*2));
+ srcRegFilt3 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch*3));
+
+ // merge the result together
+ srcRegFilt4 = _mm_unpacklo_epi8(srcRegFilt2, srcRegFilt3);
+ srcRegFilt6 = _mm_unpackhi_epi8(srcRegFilt2, srcRegFilt3);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt4 = _mm_maddubs_epi16(srcRegFilt4, secondFilters);
+ srcRegFilt6 = _mm_maddubs_epi16(srcRegFilt6, secondFilters);
+
+ // load the next 16 bytes in stride of four/five src_pitch
+ srcRegFilt2 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch*4));
+ srcRegFilt3 = _mm_loadu_si128((__m128i *)(src_ptr+src_pitch*5));
+
+ // merge the result together
+ srcRegFilt7 = _mm_unpacklo_epi8(srcRegFilt2, srcRegFilt3);
+ srcRegFilt8 = _mm_unpackhi_epi8(srcRegFilt2, srcRegFilt3);
+
+ // multiply 2 adjacent elements with the filter and add the result
+ srcRegFilt7 = _mm_maddubs_epi16(srcRegFilt7, thirdFilters);
+ srcRegFilt8 = _mm_maddubs_epi16(srcRegFilt8, thirdFilters);
+
+ // add and saturate the results together
+ srcRegFilt5 = _mm_adds_epi16(srcRegFilt5,
+ _mm_min_epi16(srcRegFilt4, srcRegFilt7));
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1,
+ _mm_min_epi16(srcRegFilt6, srcRegFilt8));
+
+ // add and saturate the results together
+ srcRegFilt5 = _mm_adds_epi16(srcRegFilt5,
+ _mm_max_epi16(srcRegFilt4, srcRegFilt7));
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1,
+ _mm_max_epi16(srcRegFilt6, srcRegFilt8));
+ srcRegFilt5 = _mm_adds_epi16(srcRegFilt5, addFilterReg64);
+ srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, addFilterReg64);
+
+ // shift by 7 bit each 16 bit
+ srcRegFilt5 = _mm_srai_epi16(srcRegFilt5, 7);
+ srcRegFilt1 = _mm_srai_epi16(srcRegFilt1, 7);
+
+ // shrink to 8 bit each 16 bits, the first lane contain the first
+ // convolve result and the second lane contain the second convolve
+ // result
+ srcRegFilt1 = _mm_packus_epi16(srcRegFilt5, srcRegFilt1);
+
+ src_ptr+=src_pitch;
+
+ // save 16 bytes convolve result
+ _mm_store_si128((__m128i*)output_ptr, srcRegFilt1);
+
+ output_ptr+=out_pitch;
+ }
+}
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index 32deec6..690bc93 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -34,7 +34,6 @@
#include "vp9/encoder/vp9_write_bit_buffer.h"
#ifdef ENTROPY_STATS
-vp9_coeff_stats tree_update_hist[TX_SIZES][PLANE_TYPES];
extern unsigned int active_section;
#endif
@@ -626,10 +625,6 @@
if (s > 0 && newp != *oldp)
u = 1;
vp9_write(bc, u, upd);
-#ifdef ENTROPY_STATS
- if (!cpi->dummy_packing)
- ++tree_update_hist[tx_size][i][j][k][l][t][u];
-#endif
if (u) {
/* send/use new probability */
vp9_write_prob_diff_update(bc, newp, *oldp);
@@ -681,10 +676,6 @@
updates += u;
if (u == 0 && updates == 0) {
noupdates_before_first++;
-#ifdef ENTROPY_STATS
- if (!cpi->dummy_packing)
- ++tree_update_hist[tx_size][i][j][k][l][t][u];
-#endif
continue;
}
if (u == 1 && updates == 1) {
@@ -695,10 +686,6 @@
vp9_write(bc, 0, upd);
}
vp9_write(bc, u, upd);
-#ifdef ENTROPY_STATS
- if (!cpi->dummy_packing)
- ++tree_update_hist[tx_size][i][j][k][l][t][u];
-#endif
if (u) {
/* send/use new probability */
vp9_write_prob_diff_update(bc, newp, *oldp);
@@ -1274,7 +1261,8 @@
first_part_size = write_compressed_header(cpi, data);
data += first_part_size;
- vp9_wb_write_literal(&saved_wb, first_part_size, 16);
+ // TODO(jbb): Figure out what to do if first_part_size > 16 bits.
+ vp9_wb_write_literal(&saved_wb, (int)first_part_size, 16);
data += encode_tiles(cpi, data);
diff --git a/vp9/encoder/vp9_dct.c b/vp9/encoder/vp9_dct.c
index a9d168c..d523239 100644
--- a/vp9/encoder/vp9_dct.c
+++ b/vp9/encoder/vp9_dct.c
@@ -47,7 +47,7 @@
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
- // as the first pass results are transposed, we tranpose the columns (that
+ // as the first pass results are transposed, we transpose the columns (that
// is the transposed rows) and transpose the results (so that it goes back
// in normal/row positions).
int pass;
@@ -315,7 +315,7 @@
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
- // as the first pass results are transposed, we tranpose the columns (that
+ // as the first pass results are transposed, we transpose the columns (that
// is the transposed rows) and transpose the results (so that it goes back
// in normal/row positions).
int pass;
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index 8023466..1a9ab60 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -1047,28 +1047,9 @@
VP9_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->mb;
MACROBLOCKD *const xd = &x->e_mbd;
- struct macroblock_plane *const p = x->plane;
- struct macroblockd_plane *const pd = xd->plane;
MB_MODE_INFO *const mbmi = &xd->mi_8x8[0]->mbmi;
const int mb_mode_index = ctx->best_mode_index;
- int max_plane;
-
- max_plane = is_inter_block(mbmi) ? MAX_MB_PLANE : 1;
- for (i = 0; i < max_plane; ++i) {
- p[i].coeff = ctx->coeff_pbuf[i][1];
- p[i].qcoeff = ctx->qcoeff_pbuf[i][1];
- pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][1];
- p[i].eobs = ctx->eobs_pbuf[i][1];
- }
-
- for (i = max_plane; i < MAX_MB_PLANE; ++i) {
- p[i].coeff = ctx->coeff_pbuf[i][2];
- p[i].qcoeff = ctx->qcoeff_pbuf[i][2];
- pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][2];
- p[i].eobs = ctx->eobs_pbuf[i][2];
- }
-
x->skip = ctx->skip;
if (frame_is_intra_only(cm)) {
@@ -1128,8 +1109,8 @@
}
static void encode_sb_rt(VP9_COMP *cpi, const TileInfo *const tile,
- TOKENEXTRA **tp, int mi_row, int mi_col,
- int output_enabled, BLOCK_SIZE bsize) {
+ TOKENEXTRA **tp, int mi_row, int mi_col,
+ int output_enabled, BLOCK_SIZE bsize) {
VP9_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->mb;
const int bsl = b_width_log2(bsize), hbs = (1 << bsl) / 4;
@@ -1147,7 +1128,6 @@
ctx = partition_plane_context(cpi->above_seg_context, cpi->left_seg_context,
mi_row, mi_col, bsize);
subsize = mi_8x8[0]->mbmi.sb_type;
-
} else {
ctx = 0;
subsize = BLOCK_4X4;
@@ -2272,11 +2252,11 @@
}
static void rtc_use_partition(VP9_COMP *cpi,
- const TileInfo *const tile,
- MODE_INFO **mi_8x8,
- TOKENEXTRA **tp, int mi_row, int mi_col,
- BLOCK_SIZE bsize, int *rate, int64_t *dist,
- int do_recon) {
+ const TileInfo *const tile,
+ MODE_INFO **mi_8x8,
+ TOKENEXTRA **tp, int mi_row, int mi_col,
+ BLOCK_SIZE bsize, int *rate, int64_t *dist,
+ int do_recon) {
VP9_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->mb;
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
@@ -2334,6 +2314,7 @@
}
}
}
+
encode_sb_rt(cpi, tile, tp, mi_row, mi_col, 1, BLOCK_64X64);
*rate = chosen_rate;
@@ -2417,6 +2398,22 @@
set_prev_mi(cm);
+ if (cpi->sf.use_pick_mode) {
+ // Initialize internal buffer pointers for rtc coding, where non-RD
+ // mode decision is used and hence no buffer pointer swap needed.
+ int i;
+ struct macroblock_plane *const p = x->plane;
+ struct macroblockd_plane *const pd = xd->plane;
+ PICK_MODE_CONTEXT *ctx = &cpi->mb.sb64_context;
+
+ for (i = 0; i < MAX_MB_PLANE; ++i) {
+ p[i].coeff = ctx->coeff_pbuf[i][0];
+ p[i].qcoeff = ctx->qcoeff_pbuf[i][0];
+ pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][0];
+ p[i].eobs = ctx->eobs_pbuf[i][0];
+ }
+ }
+
{
struct vpx_usec_timer emr_timer;
vpx_usec_timer_start(&emr_timer);
@@ -2700,6 +2697,7 @@
const int mis = cm->mode_info_stride;
const int mi_width = num_8x8_blocks_wide_lookup[bsize];
const int mi_height = num_8x8_blocks_high_lookup[bsize];
+
x->skip_recode = !x->select_txfm_size && mbmi->sb_type >= BLOCK_8X8 &&
(cpi->oxcf.aq_mode != COMPLEXITY_AQ) &&
!cpi->sf.use_pick_mode;
diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c
index 8770107..19421aa 100644
--- a/vp9/encoder/vp9_encodemb.c
+++ b/vp9/encoder/vp9_encodemb.c
@@ -36,18 +36,18 @@
};
void vp9_subtract_block_c(int rows, int cols,
- int16_t *diff_ptr, ptrdiff_t diff_stride,
- const uint8_t *src_ptr, ptrdiff_t src_stride,
- const uint8_t *pred_ptr, ptrdiff_t pred_stride) {
+ int16_t *diff, ptrdiff_t diff_stride,
+ const uint8_t *src, ptrdiff_t src_stride,
+ const uint8_t *pred, ptrdiff_t pred_stride) {
int r, c;
for (r = 0; r < rows; r++) {
for (c = 0; c < cols; c++)
- diff_ptr[c] = src_ptr[c] - pred_ptr[c];
+ diff[c] = src[c] - pred[c];
- diff_ptr += diff_stride;
- pred_ptr += pred_stride;
- src_ptr += src_stride;
+ diff += diff_stride;
+ pred += pred_stride;
+ src += src_stride;
}
}
@@ -131,9 +131,9 @@
const int ref = is_inter_block(&xd->mi_8x8[0]->mbmi);
vp9_token_state tokens[1025][2];
unsigned best_index[1025][2];
- const int16_t *coeff_ptr = BLOCK_OFFSET(mb->plane[plane].coeff, block);
- int16_t *qcoeff_ptr;
- int16_t *dqcoeff_ptr;
+ const int16_t *coeff = BLOCK_OFFSET(mb->plane[plane].coeff, block);
+ int16_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block);
+ int16_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
int eob = p->eobs[block], final_eob, sz = 0;
const int i0 = 0;
int rc, x, next, i;
@@ -143,7 +143,6 @@
PLANE_TYPE type = pd->plane_type;
int err_mult = plane_rd_mult[type];
const int default_eob = 16 << (tx_size << 1);
-
const int mul = 1 + (tx_size == TX_32X32);
uint8_t token_cache[1024];
const int16_t *dequant_ptr = pd->dequant;
@@ -153,8 +152,6 @@
const int16_t *nb = so->neighbors;
assert((!type && !plane) || (type && plane));
- dqcoeff_ptr = BLOCK_OFFSET(pd->dqcoeff, block);
- qcoeff_ptr = BLOCK_OFFSET(p->qcoeff, block);
assert(eob <= default_eob);
/* Now set up a Viterbi trellis to evaluate alternative roundings. */
@@ -172,13 +169,13 @@
next = eob;
for (i = 0; i < eob; i++)
token_cache[scan[i]] = vp9_pt_energy_class[vp9_dct_value_tokens_ptr[
- qcoeff_ptr[scan[i]]].token];
+ qcoeff[scan[i]]].token];
for (i = eob; i-- > i0;) {
int base_bits, d2, dx;
rc = scan[i];
- x = qcoeff_ptr[rc];
+ x = qcoeff[rc];
/* Only add a trellis state for non-zero coefficients. */
if (x) {
int shortcut = 0;
@@ -203,7 +200,7 @@
/* And pick the best. */
best = rd_cost1 < rd_cost0;
base_bits = *(vp9_dct_value_cost_ptr + x);
- dx = mul * (dqcoeff_ptr[rc] - coeff_ptr[rc]);
+ dx = mul * (dqcoeff[rc] - coeff[rc]);
d2 = dx * dx;
tokens[i][0].rate = base_bits + (best ? rate1 : rate0);
tokens[i][0].error = d2 + (best ? error1 : error0);
@@ -216,8 +213,8 @@
rate0 = tokens[next][0].rate;
rate1 = tokens[next][1].rate;
- if ((abs(x)*dequant_ptr[rc != 0] > abs(coeff_ptr[rc]) * mul) &&
- (abs(x)*dequant_ptr[rc != 0] < abs(coeff_ptr[rc]) * mul +
+ if ((abs(x)*dequant_ptr[rc != 0] > abs(coeff[rc]) * mul) &&
+ (abs(x)*dequant_ptr[rc != 0] < abs(coeff[rc]) * mul +
dequant_ptr[rc != 0]))
shortcut = 1;
else
@@ -306,16 +303,16 @@
UPDATE_RD_COST();
best = rd_cost1 < rd_cost0;
final_eob = i0 - 1;
- vpx_memset(qcoeff_ptr, 0, sizeof(*qcoeff_ptr) * (16 << (tx_size * 2)));
- vpx_memset(dqcoeff_ptr, 0, sizeof(*dqcoeff_ptr) * (16 << (tx_size * 2)));
+ vpx_memset(qcoeff, 0, sizeof(*qcoeff) * (16 << (tx_size * 2)));
+ vpx_memset(dqcoeff, 0, sizeof(*dqcoeff) * (16 << (tx_size * 2)));
for (i = next; i < eob; i = next) {
x = tokens[i][best].qc;
if (x) {
final_eob = i;
}
rc = scan[i];
- qcoeff_ptr[rc] = x;
- dqcoeff_ptr[rc] = (x * dequant_ptr[rc != 0]) / mul;
+ qcoeff[rc] = x;
+ dqcoeff[rc] = (x * dequant_ptr[rc != 0]) / mul;
next = tokens[i][best].next;
best = best_index[i][best];
@@ -348,6 +345,15 @@
pd->above_context, pd->left_context,
num_4x4_w, num_4x4_h);
}
+
+static INLINE void fdct32x32(int rd_transform,
+ const int16_t *src, int16_t *dst, int src_stride) {
+ if (rd_transform)
+ vp9_fdct32x32_rd(src, dst, src_stride);
+ else
+ vp9_fdct32x32(src, dst, src_stride);
+}
+
void vp9_xform_quant(MACROBLOCK *x, int plane, int block,
BLOCK_SIZE plane_bsize, TX_SIZE tx_size) {
MACROBLOCKD *const xd = &x->e_mbd;
@@ -367,10 +373,7 @@
switch (tx_size) {
case TX_32X32:
scan_order = &vp9_default_scan_orders[TX_32X32];
- if (x->use_lp32x32fdct)
- vp9_fdct32x32_rd(src_diff, coeff, diff_stride);
- else
- vp9_fdct32x32(src_diff, coeff, diff_stride);
+ fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob, scan_order->scan,
@@ -536,10 +539,12 @@
uint8_t *src, *dst;
int16_t *src_diff;
uint16_t *eob = &p->eobs[block];
+ const int src_stride = p->src.stride;
+ const int dst_stride = pd->dst.stride;
int i, j;
txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
- dst = &pd->dst.buf[4 * (j * pd->dst.stride + i)];
- src = &p->src.buf[4 * (j * p->src.stride + i)];
+ dst = &pd->dst.buf[4 * (j * dst_stride + i)];
+ src = &p->src.buf[4 * (j * src_stride + i)];
src_diff = &p->src_diff[4 * (j * diff_stride + i)];
// if (x->optimize)
@@ -551,22 +556,19 @@
mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
vp9_predict_intra_block(xd, block >> 6, bwl, TX_32X32, mode,
x->skip_encode ? src : dst,
- x->skip_encode ? p->src.stride : pd->dst.stride,
- dst, pd->dst.stride, i, j, plane);
+ x->skip_encode ? src_stride : dst_stride,
+ dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_subtract_block(32, 32, src_diff, diff_stride,
- src, p->src.stride, dst, pd->dst.stride);
- if (x->use_lp32x32fdct)
- vp9_fdct32x32_rd(src_diff, coeff, diff_stride);
- else
- vp9_fdct32x32(src_diff, coeff, diff_stride);
+ src, src_stride, dst, dst_stride);
+ fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob, scan_order->scan,
scan_order->iscan);
}
if (!x->skip_encode && *eob)
- vp9_idct32x32_add(dqcoeff, dst, pd->dst.stride, *eob);
+ vp9_idct32x32_add(dqcoeff, dst, dst_stride, *eob);
break;
case TX_16X16:
tx_type = get_tx_type_16x16(pd->plane_type, xd);
@@ -574,11 +576,11 @@
mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
vp9_predict_intra_block(xd, block >> 4, bwl, TX_16X16, mode,
x->skip_encode ? src : dst,
- x->skip_encode ? p->src.stride : pd->dst.stride,
- dst, pd->dst.stride, i, j, plane);
+ x->skip_encode ? src_stride : dst_stride,
+ dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_subtract_block(16, 16, src_diff, diff_stride,
- src, p->src.stride, dst, pd->dst.stride);
+ src, src_stride, dst, dst_stride);
vp9_fht16x16(src_diff, coeff, diff_stride, tx_type);
vp9_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
@@ -586,7 +588,7 @@
scan_order->iscan);
}
if (!x->skip_encode && *eob)
- vp9_iht16x16_add(tx_type, dqcoeff, dst, pd->dst.stride, *eob);
+ vp9_iht16x16_add(tx_type, dqcoeff, dst, dst_stride, *eob);
break;
case TX_8X8:
tx_type = get_tx_type_8x8(pd->plane_type, xd);
@@ -594,11 +596,11 @@
mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
vp9_predict_intra_block(xd, block >> 2, bwl, TX_8X8, mode,
x->skip_encode ? src : dst,
- x->skip_encode ? p->src.stride : pd->dst.stride,
- dst, pd->dst.stride, i, j, plane);
+ x->skip_encode ? src_stride : dst_stride,
+ dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_subtract_block(8, 8, src_diff, diff_stride,
- src, p->src.stride, dst, pd->dst.stride);
+ src, src_stride, dst, dst_stride);
vp9_fht8x8(src_diff, coeff, diff_stride, tx_type);
vp9_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round, p->quant,
p->quant_shift, qcoeff, dqcoeff,
@@ -606,7 +608,7 @@
scan_order->iscan);
}
if (!x->skip_encode && *eob)
- vp9_iht8x8_add(tx_type, dqcoeff, dst, pd->dst.stride, *eob);
+ vp9_iht8x8_add(tx_type, dqcoeff, dst, dst_stride, *eob);
break;
case TX_4X4:
tx_type = get_tx_type_4x4(pd->plane_type, xd, block);
@@ -618,12 +620,12 @@
vp9_predict_intra_block(xd, block, bwl, TX_4X4, mode,
x->skip_encode ? src : dst,
- x->skip_encode ? p->src.stride : pd->dst.stride,
- dst, pd->dst.stride, i, j, plane);
+ x->skip_encode ? src_stride : dst_stride,
+ dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_subtract_block(4, 4, src_diff, diff_stride,
- src, p->src.stride, dst, pd->dst.stride);
+ src, src_stride, dst, dst_stride);
if (tx_type != DCT_DCT)
vp9_fht4x4(src_diff, coeff, diff_stride, tx_type);
else
@@ -639,9 +641,9 @@
// this is like vp9_short_idct4x4 but has a special case around eob<=1
// which is significant (not just an optimization) for the lossless
// case.
- xd->itxm_add(dqcoeff, dst, pd->dst.stride, *eob);
+ xd->itxm_add(dqcoeff, dst, dst_stride, *eob);
else
- vp9_iht4x4_16_add(dqcoeff, dst, pd->dst.stride, tx_type);
+ vp9_iht4x4_16_add(dqcoeff, dst, dst_stride, tx_type);
}
break;
default:
diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c
index bf9dd3e..c2aac3e 100644
--- a/vp9/encoder/vp9_firstpass.c
+++ b/vp9/encoder/vp9_firstpass.c
@@ -65,7 +65,7 @@
double target_q = (vp9_convert_qindex_to_q(qindex) * 0.5847) + 1.0;
- for (i = 0; i < QINDEX_RANGE; i++) {
+ for (i = 0; i < QINDEX_RANGE; ++i) {
if (target_q <= vp9_convert_qindex_to_q(i)) {
ret_val = i;
break;
@@ -106,12 +106,12 @@
}
-// Read frame stats at an offset from the current position
+// Read frame stats at an offset from the current position.
static int read_frame_stats(const struct twopass_rc *p,
FIRSTPASS_STATS *frame_stats, int offset) {
const FIRSTPASS_STATS *fps_ptr = p->stats_in;
- // Check legality of offset
+ // Check legality of offset.
if (offset >= 0) {
if (&fps_ptr[offset] >= p->stats_in_end)
return EOF;
@@ -144,7 +144,6 @@
// TEMP debug code
#if OUTPUT_FPF
-
{
FILE *fpfile;
fpfile = fopen("firstpass.stt", "a");
@@ -377,7 +376,6 @@
const int src_stride = x->plane[0].src.stride;
const uint8_t *const ref = xd->plane[0].pre[0].buf;
const int ref_stride = xd->plane[0].pre[0].stride;
-
unsigned int sse;
vp9_variance_fn_t fn = get_block_variance_fn(xd->mi_8x8[0]->mbmi.sb_type);
fn(src, src_stride, ref, ref_stride, &sse);
@@ -398,18 +396,18 @@
int new_mv_mode_penalty = 256;
const int quart_frm = MIN(cpi->common.width, cpi->common.height);
- // refine the motion search range accroding to the frame dimension
- // for first pass test
+ // Refine the motion search range according to the frame dimension
+ // for first pass test.
while ((quart_frm << sr) < MAX_FULL_PEL_VAL)
- sr++;
+ ++sr;
step_param += sr;
further_steps -= sr;
- // override the default variance function to use MSE
+ // Override the default variance function to use MSE.
v_fn_ptr.vf = get_block_variance_fn(bsize);
- // Initial step/diamond search centred on best mv
+ // Center the initial step/diamond search on best mv.
tmp_err = cpi->diamond_search_sad(x, &ref_mv_full, &tmp_mv,
step_param,
x->sadperbit16, &num00, &v_fn_ptr,
@@ -424,15 +422,15 @@
best_mv->col = tmp_mv.col;
}
- // Further step/diamond searches as necessary
+ // Carry out further step/diamond searches as necessary.
n = num00;
num00 = 0;
while (n < further_steps) {
- n++;
+ ++n;
if (num00) {
- num00--;
+ --num00;
} else {
tmp_err = cpi->diamond_search_sad(x, &ref_mv_full, &tmp_mv,
step_param + n, x->sadperbit16,
@@ -504,7 +502,7 @@
setup_dst_planes(xd, new_yv12, 0, 0);
xd->mi_8x8 = cm->mi_grid_visible;
- xd->mi_8x8[0] = cm->mi; // required for vp9_frame_init_quantizer
+ xd->mi_8x8[0] = cm->mi;
vp9_setup_block_planes(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);
@@ -521,28 +519,26 @@
vp9_init_mv_probs(cm);
vp9_initialize_rd_consts(cpi);
- // tiling is ignored in the first pass
+ // Tiling is ignored in the first pass.
vp9_tile_init(&tile, cm, 0, 0);
- // for each macroblock row in image
- for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
+ for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) {
int_mv best_ref_mv;
best_ref_mv.as_int = 0;
- // reset above block coeffs
+ // Reset above block coeffs.
xd->up_available = (mb_row != 0);
recon_yoffset = (mb_row * recon_y_stride * 16);
recon_uvoffset = (mb_row * recon_uv_stride * uv_mb_height);
// Set up limit values for motion vectors to prevent them extending
- // outside the UMV borders
+ // outside the UMV borders.
x->mv_row_min = -((mb_row * 16) + BORDER_MV_PIXELS_B16);
x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16)
+ BORDER_MV_PIXELS_B16;
- // for each macroblock col in image
- for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
+ for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {
int this_error;
const int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
double error_weight = 1.0;
@@ -566,15 +562,15 @@
error_weight = vp9_vaq_inv_q_ratio(energy);
}
- // do intra 16x16 prediction
+ // Do intra 16x16 prediction.
this_error = vp9_encode_intra(x, use_dc_pred);
if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
vp9_clear_system_state(); // __asm emms;
- this_error *= error_weight;
+ this_error = (int)(this_error * error_weight);
}
- // intrapenalty below deals with situations where the intra and inter
- // error scores are very low (eg a plain black frame).
+ // Intrapenalty below deals with situations where the intra and inter
+ // error scores are very low (e.g. a plain black frame).
// We do not have special cases in first pass for 0,0 and nearest etc so
// all inter modes carry an overhead cost estimate for the mv.
// When the error score is very low this causes us to pick all or lots of
@@ -582,7 +578,7 @@
// This penalty adds a cost matching that of a 0,0 mv to the intra case.
this_error += intrapenalty;
- // Cumulative intra error total
+ // Accumulate the intra error.
intra_error += (int64_t)this_error;
// Set up limit values for motion vectors to prevent them extending
@@ -590,23 +586,23 @@
x->mv_col_min = -((mb_col * 16) + BORDER_MV_PIXELS_B16);
x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + BORDER_MV_PIXELS_B16;
- // Other than for the first frame do a motion search
+ // Other than for the first frame do a motion search.
if (cm->current_video_frame > 0) {
int tmp_err, motion_error;
int_mv mv, tmp_mv;
xd->plane[0].pre[0].buf = lst_yv12->y_buffer + recon_yoffset;
motion_error = zz_motion_search(cpi, x);
- // Simple 0,0 motion with no mv overhead
+ // Assume 0,0 motion with no mv overhead.
mv.as_int = tmp_mv.as_int = 0;
// Test last reference frame using the previous best mv as the
- // starting point (best reference) for the search
+ // starting point (best reference) for the search.
first_pass_motion_search(cpi, x, &best_ref_mv.as_mv, &mv.as_mv,
&motion_error);
if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
vp9_clear_system_state(); // __asm emms;
- motion_error *= error_weight;
+ motion_error = (int)(motion_error * error_weight);
}
// If the current best reference mv is not centered on 0,0 then do a 0,0
@@ -617,7 +613,7 @@
&tmp_err);
if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
vp9_clear_system_state(); // __asm emms;
- tmp_err *= error_weight;
+ tmp_err = (int)(tmp_err * error_weight);
}
if (tmp_err < motion_error) {
@@ -626,9 +622,9 @@
}
}
- // Experimental search in an older reference frame
+ // Search in an older reference frame.
if (cm->current_video_frame > 1) {
- // Simple 0,0 motion with no mv overhead
+ // Assume 0,0 motion with no mv overhead.
int gf_motion_error;
xd->plane[0].pre[0].buf = gld_yv12->y_buffer + recon_yoffset;
@@ -638,21 +634,21 @@
&gf_motion_error);
if (cpi->oxcf.aq_mode == VARIANCE_AQ) {
vp9_clear_system_state(); // __asm emms;
- gf_motion_error *= error_weight;
+ gf_motion_error = (int)(gf_motion_error * error_weight);
}
if (gf_motion_error < motion_error && gf_motion_error < this_error)
- second_ref_count++;
+ ++second_ref_count;
- // Reset to last frame as reference buffer
+ // Reset to last frame as reference buffer.
xd->plane[0].pre[0].buf = lst_yv12->y_buffer + recon_yoffset;
xd->plane[1].pre[0].buf = lst_yv12->u_buffer + recon_uvoffset;
xd->plane[2].pre[0].buf = lst_yv12->v_buffer + recon_uvoffset;
- // In accumulating a score for the older reference frame
- // take the best of the motion predicted score and
- // the intra coded error (just as will be done for)
- // accumulation of "coded_error" for the last frame.
+ // In accumulating a score for the older reference frame take the
+ // best of the motion predicted score and the intra coded error
+ // (just as will be done for) accumulation of "coded_error" for
+ // the last frame.
if (gf_motion_error < this_error)
sr_coded_error += gf_motion_error;
else
@@ -660,17 +656,16 @@
} else {
sr_coded_error += motion_error;
}
- /* Intra assumed best */
+ // Start by assuming that intra mode is best.
best_ref_mv.as_int = 0;
if (motion_error <= this_error) {
- // Keep a count of cases where the inter and intra were
- // very close and very low. This helps with scene cut
- // detection for example in cropped clips with black bars
- // at the sides or top and bottom.
+ // Keep a count of cases where the inter and intra were very close
+ // and very low. This helps with scene cut detection for example in
+ // cropped clips with black bars at the sides or top and bottom.
if (((this_error - intrapenalty) * 9 <= motion_error * 10) &&
this_error < 2 * intrapenalty)
- neutral_count++;
+ ++neutral_count;
mv.as_mv.row *= 8;
mv.as_mv.col *= 8;
@@ -687,43 +682,42 @@
sum_mvc_abs += abs(mv.as_mv.col);
sum_mvrs += mv.as_mv.row * mv.as_mv.row;
sum_mvcs += mv.as_mv.col * mv.as_mv.col;
- intercount++;
+ ++intercount;
best_ref_mv.as_int = mv.as_int;
- // Was the vector non-zero
if (mv.as_int) {
- mvcount++;
+ ++mvcount;
- // Was it different from the last non zero vector
+ // Non-zero vector, was it different from the last non zero vector?
if (mv.as_int != lastmv_as_int)
- new_mv_count++;
+ ++new_mv_count;
lastmv_as_int = mv.as_int;
- // Does the Row vector point inwards or outwards
+ // Does the row vector point inwards or outwards?
if (mb_row < cm->mb_rows / 2) {
if (mv.as_mv.row > 0)
- sum_in_vectors--;
+ --sum_in_vectors;
else if (mv.as_mv.row < 0)
- sum_in_vectors++;
+ ++sum_in_vectors;
} else if (mb_row > cm->mb_rows / 2) {
if (mv.as_mv.row > 0)
- sum_in_vectors++;
+ ++sum_in_vectors;
else if (mv.as_mv.row < 0)
- sum_in_vectors--;
+ --sum_in_vectors;
}
- // Does the Row vector point inwards or outwards
+ // Does the col vector point inwards or outwards?
if (mb_col < cm->mb_cols / 2) {
if (mv.as_mv.col > 0)
- sum_in_vectors--;
+ --sum_in_vectors;
else if (mv.as_mv.col < 0)
- sum_in_vectors++;
+ ++sum_in_vectors;
} else if (mb_col > cm->mb_cols / 2) {
if (mv.as_mv.col > 0)
- sum_in_vectors++;
+ ++sum_in_vectors;
else if (mv.as_mv.col < 0)
- sum_in_vectors--;
+ --sum_in_vectors;
}
}
}
@@ -732,7 +726,7 @@
}
coded_error += (int64_t)this_error;
- // adjust to the next column of macroblocks
+ // Adjust to the next column of MBs.
x->plane[0].src.buf += 16;
x->plane[1].src.buf += uv_mb_height;
x->plane[2].src.buf += uv_mb_height;
@@ -741,7 +735,7 @@
recon_uvoffset += uv_mb_height;
}
- // adjust to the next row of mbs
+ // Adjust to the next row of MBs.
x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
x->plane[1].src.buf += uv_mb_height * x->plane[1].src.stride -
uv_mb_height * cm->mb_cols;
@@ -756,9 +750,9 @@
FIRSTPASS_STATS fps;
fps.frame = cm->current_video_frame;
- fps.intra_error = intra_error >> 8;
- fps.coded_error = coded_error >> 8;
- fps.sr_coded_error = sr_coded_error >> 8;
+ fps.intra_error = (double)(intra_error >> 8);
+ fps.coded_error = (double)(coded_error >> 8);
+ fps.sr_coded_error = (double)(sr_coded_error >> 8);
fps.ssim_weighted_pred_err = fps.coded_error * simple_weight(cpi->Source);
fps.count = 1.0;
fps.pcnt_inter = (double)intercount / cm->MBs;
@@ -792,14 +786,14 @@
// cpi->source_time_stamp.
fps.duration = (double)(cpi->source->ts_end - cpi->source->ts_start);
- // don't want to do output stats with a stack variable!
+ // Don't want to do output stats with a stack variable!
twopass->this_frame_stats = fps;
output_stats(cpi, cpi->output_pkt_list, &twopass->this_frame_stats);
accumulate_stats(&twopass->total_stats, &fps);
}
// Copy the previous Last Frame back into gf and and arf buffers if
- // the prediction is good enough... but also dont allow it to lag too far
+ // the prediction is good enough... but also don't allow it to lag too far.
if ((twopass->sr_update_lag > 3) ||
((cm->current_video_frame > 0) &&
(twopass->this_frame_stats.pcnt_inter > 0.20) &&
@@ -808,9 +802,9 @@
vp8_yv12_copy_frame(lst_yv12, gld_yv12);
twopass->sr_update_lag = 1;
} else {
- twopass->sr_update_lag++;
+ ++twopass->sr_update_lag;
}
- // swap frame pointers so last frame refers to the frame we just compressed
+ // Swap frame pointers so last frame refers to the frame we just compressed.
swap_yv12(lst_yv12, new_yv12);
vp9_extend_frame_borders(lst_yv12, cm->subsampling_x, cm->subsampling_y);
@@ -820,7 +814,7 @@
if (cm->current_video_frame == 0)
vp8_yv12_copy_frame(lst_yv12, gld_yv12);
- // use this to see what the first pass reconstruction looks like
+ // Use this to see what the first pass reconstruction looks like.
if (0) {
char filename[512];
FILE *recon_file;
@@ -836,15 +830,11 @@
fclose(recon_file);
}
- cm->current_video_frame++;
+ ++cm->current_video_frame;
}
-// Estimate a cost per mb attributable to overheads such as the coding of
-// modes and motion vectors.
-// Currently simplistic in its assumptions for testing.
-//
-
-
+// Estimate a cost per mb attributable to overheads such as the coding of modes
+// and motion vectors. This currently makes simplistic assumptions for testing.
static double bitcost(double prob) {
return -(log(prob) / log(2.0));
}
@@ -867,18 +857,17 @@
motion_cost = bitcost(av_pct_motion);
intra_cost = bitcost(av_intra);
- // Estimate of extra bits per mv overhead for mbs
- // << 9 is the normalization to the (bits * 512) used in vp9_rc_bits_per_mb
+ // Estimate the number of extra bits per mv overhead for mbs. We shift (<< 9)
+ // to match the scaling of number of bits by 512.
mv_cost = ((int)(fpstats->new_mv_count / fpstats->count) * 8) << 9;
- // Crude estimate of overhead cost from modes
- // << 9 is the normalization to (bits * 512) used in vp9_rc_bits_per_mb
+ // Produce a crude estimate of the overhead cost from modes. We shift (<< 9)
+ // to match the scaling of number of bits by 512.
mode_cost =
(int)((((av_pct_inter - av_pct_motion) * zz_cost) +
(av_pct_motion * motion_cost) +
(av_intra * intra_cost)) * cpi->common.MBs) << 9;
- // return mv_cost + mode_cost;
// TODO(paulwilkins): Fix overhead costs for extended Q range.
#endif
return 0;
@@ -895,7 +884,7 @@
const double power_term = MIN(vp9_convert_qindex_to_q(q) * 0.0125 + pt_low,
pt_high);
- // Calculate correction factor
+ // Calculate correction factor.
if (power_term < 1.0)
assert(error_term >= 0.0);
@@ -921,7 +910,7 @@
// Try and pick a max Q that will be high enough to encode the
// content at the given rate.
- for (q = rc->best_quality; q < rc->worst_quality; q++) {
+ for (q = rc->best_quality; q < rc->worst_quality; ++q) {
const double err_correction_factor = calc_correction_factor(err_per_mb,
ERR_DIVISOR, 0.5, 0.90, q);
const int bits_per_mb_at_this_q = vp9_rc_bits_per_mb(INTER_FRAME, q,
@@ -954,11 +943,11 @@
twopass->total_stats = *twopass->stats_in_end;
twopass->total_left_stats = twopass->total_stats;
- // each frame can have a different duration, as the frame rate in the source
- // isn't guaranteed to be constant. The frame rate prior to the first frame
- // encoded in the second pass is a guess. However the sum duration is not.
- // Its calculated based on the actual durations of all frames from the first
- // pass.
+ // Each frame can have a different duration, as the frame rate in the source
+ // isn't guaranteed to be constant. The frame rate prior to the first frame
+ // encoded in the second pass is a guess. However, the sum duration is not.
+ // It is calculated based on the actual durations of all frames from the
+ // first pass.
vp9_new_framerate(cpi, 10000000.0 * twopass->total_stats.count /
twopass->total_stats.duration);
@@ -969,18 +958,18 @@
// 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
+ // are still boosted appropriately for KF/GF/ARF.
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
+ // This variable monitors how far behind the second ref update is lagging.
twopass->sr_update_lag = 1;
// Scan the first pass file and calculate an average Intra / Inter error score
// ratio for the sequence.
{
double sum_iiratio = 0.0;
- start_pos = twopass->stats_in; // Note the starting "file" position.
+ start_pos = twopass->stats_in;
while (input_stats(twopass, &this_frame) != EOF) {
const double iiratio = this_frame.intra_error /
@@ -991,7 +980,6 @@
twopass->avg_iiratio = sum_iiratio /
DOUBLE_DIVIDE_CHECK((double)twopass->total_stats.count);
- // Reset file position
reset_fpf_position(twopass, start_pos);
}
@@ -1001,7 +989,7 @@
double av_error = twopass->total_stats.ssim_weighted_pred_err /
DOUBLE_DIVIDE_CHECK(twopass->total_stats.count);
- start_pos = twopass->stats_in; // Note starting "file" position
+ start_pos = twopass->stats_in;
twopass->modified_error_total = 0.0;
twopass->modified_error_min =
@@ -1022,8 +1010,8 @@
void vp9_end_second_pass(VP9_COMP *cpi) {
}
-// This function gives and estimate of how badly we believe
-// the prediction quality is decaying from frame to frame.
+// 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
@@ -1056,9 +1044,8 @@
FIRSTPASS_STATS *position = cpi->twopass.stats_in;
FIRSTPASS_STATS tmp_next_frame;
- // Look ahead a few frames to see if static condition
- // persists...
- for (j = 0; j < still_interval; j++) {
+ // Look ahead a few frames to see if static condition persists...
+ for (j = 0; j < still_interval; ++j) {
if (EOF == input_stats(&cpi->twopass, &tmp_next_frame))
break;
@@ -1068,7 +1055,7 @@
reset_fpf_position(&cpi->twopass, position);
- // Only if it does do we signal a transition to still
+ // Only if it does do we signal a transition to still.
if (j == still_interval)
trans_to_still = 1;
}
@@ -1078,7 +1065,7 @@
// This function detects a flash through the high relative pcnt_second_ref
// score in the frame following a flash frame. The offset passed in should
-// reflect this
+// reflect this.
static int detect_flash(const struct twopass_rc *twopass, int offset) {
FIRSTPASS_STATS next_frame;
@@ -1091,7 +1078,7 @@
// brief break in prediction (such as a flash) but subsequent frames
// are reasonably well predicted by an earlier (pre flash) frame.
// The recovery after a flash is indicated by a high pcnt_second_ref
- // comapred to pcnt_inter.
+ // compared to pcnt_inter.
if (next_frame.pcnt_second_ref > next_frame.pcnt_inter &&
next_frame.pcnt_second_ref >= 0.5)
flash_detected = 1;
@@ -1100,7 +1087,7 @@
return flash_detected;
}
-// Update the motion related elements to the GF arf boost calculation
+// Update the motion related elements to the GF arf boost calculation.
static void accumulate_frame_motion_stats(
FIRSTPASS_STATS *this_frame,
double *this_frame_mv_in_out,
@@ -1112,13 +1099,13 @@
// Accumulate motion stats.
motion_pct = this_frame->pcnt_motion;
- // Accumulate Motion In/Out of frame stats
+ // Accumulate Motion In/Out of frame stats.
*this_frame_mv_in_out = this_frame->mv_in_out_count * motion_pct;
*mv_in_out_accumulator += this_frame->mv_in_out_count * motion_pct;
*abs_mv_in_out_accumulator += fabs(this_frame->mv_in_out_count * motion_pct);
// Accumulate a measure of how uniform (or conversely how random)
- // the motion field is. (A ratio of absmv / mv)
+ // the motion field is (a ratio of absmv / mv).
if (motion_pct > 0.05) {
const double this_frame_mvr_ratio = fabs(this_frame->mvr_abs) /
DOUBLE_DIVIDE_CHECK(fabs(this_frame->MVr));
@@ -1141,7 +1128,7 @@
double this_frame_mv_in_out) {
double frame_boost;
- // Underlying boost factor is based on inter intra error ratio
+ // Underlying boost factor is based on inter intra error ratio.
if (this_frame->intra_error > cpi->twopass.gf_intra_err_min)
frame_boost = (IIFACTOR * this_frame->intra_error /
DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
@@ -1149,13 +1136,12 @@
frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min /
DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
- // Increase boost for frames where new data coming into frame
- // (eg zoom out). Slightly reduce boost if there is a net balance
- // of motion out of the frame (zoom in).
- // The range for this_frame_mv_in_out is -1.0 to +1.0
+ // 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
+ // (zoom in). The range for this_frame_mv_in_out is -1.0 to +1.0.
if (this_frame_mv_in_out > 0.0)
frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
- // In extreme case boost is halved
+ // In the extreme case the boost is halved.
else
frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);
@@ -1177,12 +1163,12 @@
int arf_boost;
int flash_detected = 0;
- // Search forward from the proposed arf/next gf position
- for (i = 0; i < f_frames; i++) {
+ // Search forward from the proposed arf/next gf position.
+ for (i = 0; i < f_frames; ++i) {
if (read_frame_stats(twopass, &this_frame, (i + offset)) == EOF)
break;
- // Update the motion related elements to the boost calculation
+ // Update the motion related elements to the boost calculation.
accumulate_frame_motion_stats(&this_frame,
&this_frame_mv_in_out, &mv_in_out_accumulator,
&abs_mv_in_out_accumulator,
@@ -1193,7 +1179,7 @@
flash_detected = detect_flash(twopass, i + offset) ||
detect_flash(twopass, i + offset + 1);
- // Cumulative effect of prediction quality decay
+ // Accumulate the effect of prediction quality decay.
if (!flash_detected) {
decay_accumulator *= get_prediction_decay_rate(&cpi->common, &this_frame);
decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
@@ -1206,7 +1192,7 @@
*f_boost = (int)boost_score;
- // Reset for backward looking loop
+ // Reset for backward looking loop.
boost_score = 0.0;
mv_ratio_accumulator = 0.0;
decay_accumulator = 1.0;
@@ -1214,12 +1200,12 @@
mv_in_out_accumulator = 0.0;
abs_mv_in_out_accumulator = 0.0;
- // Search backward towards last gf position
- for (i = -1; i >= -b_frames; i--) {
+ // Search backward towards last gf position.
+ for (i = -1; i >= -b_frames; --i) {
if (read_frame_stats(twopass, &this_frame, (i + offset)) == EOF)
break;
- // Update the motion related elements to the boost calculation
+ // Update the motion related elements to the boost calculation.
accumulate_frame_motion_stats(&this_frame,
&this_frame_mv_in_out, &mv_in_out_accumulator,
&abs_mv_in_out_accumulator,
@@ -1230,7 +1216,7 @@
flash_detected = detect_flash(twopass, i + offset) ||
detect_flash(twopass, i + offset + 1);
- // Cumulative effect of prediction quality decay
+ // Cumulative effect of prediction quality decay.
if (!flash_detected) {
decay_accumulator *= get_prediction_decay_rate(&cpi->common, &this_frame);
decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR
@@ -1280,8 +1266,7 @@
return;
}
- // ARF Group: work out the ARF schedule.
- // Mark ARF frames as negative.
+ // ARF Group: Work out the ARF schedule and mark ARF frames as negative.
if (end < 0) {
// printf("start:%d end:%d\n", -end, -end);
// ARF frame is at the end of the range.
@@ -1404,14 +1389,14 @@
double decay_accumulator = 1.0;
double zero_motion_accumulator = 1.0;
- double loop_decay_rate = 1.00; // Starting decay rate
+ double loop_decay_rate = 1.00;
double last_loop_decay_rate = 1.00;
double this_frame_mv_in_out = 0.0;
double mv_in_out_accumulator = 0.0;
double abs_mv_in_out_accumulator = 0.0;
double mv_ratio_accumulator_thresh;
- const int max_bits = frame_max_bits(cpi); // Max for a single frame
+ const int max_bits = frame_max_bits(cpi); // Max bits for a single frame.
unsigned int allow_alt_ref = cpi->oxcf.play_alternate &&
cpi->oxcf.lag_in_frames;
@@ -1431,12 +1416,12 @@
// Load stats for the current frame.
mod_frame_err = calculate_modified_err(cpi, this_frame);
- // Note the error of the frame at the start of the group (this will be
- // the GF frame error if we code a normal gf
+ // Note the error of the frame at the start of the group. This will be
+ // the GF frame error if we code a normal gf.
gf_first_frame_err = mod_frame_err;
// If this is a key frame or the overlay from a previous arf then
- // The error score / cost of this frame has already been accounted for.
+ // the error score / cost of this frame has already been accounted for.
if (cpi->common.frame_type == KEY_FRAME || rc->source_alt_ref_active)
gf_group_err -= gf_first_frame_err;
@@ -1458,9 +1443,9 @@
i = 0;
while (i < twopass->static_scene_max_gf_interval && i < rc->frames_to_key) {
- i++; // Increment the loop counter
+ ++i;
- // Accumulate error score of frames in this gf group
+ // Accumulate error score of frames in this gf group.
mod_frame_err = calculate_modified_err(cpi, this_frame);
gf_group_err += mod_frame_err;
@@ -1471,13 +1456,13 @@
// quality back to an earlier frame is then restored.
flash_detected = detect_flash(twopass, 0);
- // Update the motion related elements to the boost calculation
+ // Update the motion related elements to the boost calculation.
accumulate_frame_motion_stats(&next_frame,
&this_frame_mv_in_out, &mv_in_out_accumulator,
&abs_mv_in_out_accumulator,
&mv_ratio_accumulator);
- // Cumulative effect of prediction quality decay
+ // Accumulate the effect of prediction quality decay.
if (!flash_detected) {
last_loop_decay_rate = loop_decay_rate;
loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame);
@@ -1490,8 +1475,8 @@
next_frame.pcnt_motion;
}
- // Break clause to detect very still sections after motion
- // (for example a static image after a fade or other transition).
+ // Break clause to detect very still sections after motion. For example,
+ // a static image after a fade or other transition.
if (detect_transition_to_still(cpi, i, 5, loop_decay_rate,
last_loop_decay_rate)) {
allow_alt_ref = 0;
@@ -1499,16 +1484,16 @@
}
}
- // Calculate a boost number for this frame
+ // Calculate a boost number for this frame.
boost_score += (decay_accumulator *
calc_frame_boost(cpi, &next_frame, this_frame_mv_in_out));
// Break out conditions.
if (
- // Break at cpi->max_gf_interval unless almost totally static
+ // Break at cpi->max_gf_interval unless almost totally static.
(i >= active_max_gf_interval && (zero_motion_accumulator < 0.995)) ||
(
- // Don't break out with a very short interval
+ // 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) &&
@@ -1527,10 +1512,10 @@
twopass->gf_zeromotion_pct = (int)(zero_motion_accumulator * 1000.0);
- // Don't allow a gf too near the next kf
+ // 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++;
+ ++i;
if (EOF == input_stats(twopass, this_frame))
break;
@@ -1560,14 +1545,14 @@
else
rc->baseline_gf_interval = i;
- // Should we use the alternate reference 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) dont allow arf very near kf.
+ // 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)))) {
- // Alternative boost calculation for alt ref
+ // Calculate the boost for alt ref.
rc->gfu_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost,
&b_boost);
rc->source_alt_ref_pending = 1;
@@ -1629,7 +1614,7 @@
#endif
#endif
- // Calculate the bits to be allocated to the group as a whole
+ // Calculate the bits to be allocated to the group as a whole.
if (twopass->kf_group_bits > 0 && twopass->kf_group_error_left > 0) {
twopass->gf_group_bits = (int64_t)(cpi->twopass.kf_group_bits *
(gf_group_err / cpi->twopass.kf_group_error_left));
@@ -1641,11 +1626,11 @@
twopass->kf_group_bits : twopass->gf_group_bits;
// Clip cpi->twopass.gf_group_bits based on user supplied data rate
- // variability limit (cpi->oxcf.two_pass_vbrmax_section)
+ // variability limit, cpi->oxcf.two_pass_vbrmax_section.
if (twopass->gf_group_bits > (int64_t)max_bits * rc->baseline_gf_interval)
twopass->gf_group_bits = (int64_t)max_bits * rc->baseline_gf_interval;
- // Reset the file position
+ // Reset the file position.
reset_fpf_position(twopass, start_pos);
// Assign bits to the arf or gf.
@@ -1657,7 +1642,7 @@
int boost = (rc->gfu_boost * gfboost_qadjust(q)) / 100;
- // Set max and minimum boost and hence minimum allocation
+ // Set max and minimum boost and hence minimum allocation.
boost = clamp(boost, 125, (rc->baseline_gf_interval + 1) * 200);
if (rc->source_alt_ref_pending && i == 0)
@@ -1665,7 +1650,7 @@
else
allocation_chunks = (rc->baseline_gf_interval * 100) + (boost - 100);
- // Prevent overflow
+ // Prevent overflow.
if (boost > 1023) {
int divisor = boost >> 10;
boost /= divisor;
@@ -1673,13 +1658,13 @@
}
// Calculate the number of bits to be spent on the gf or arf based on
- // the boost number
+ // the boost number.
gf_bits = (int)((double)boost * (twopass->gf_group_bits /
(double)allocation_chunks));
// If the frame that is to be boosted is simpler than the average for
// the gf/arf group then use an alternative calculation
- // based on the error score of the frame itself
+ // based on the error score of the frame itself.
if (rc->baseline_gf_interval < 1 ||
mod_frame_err < gf_group_err / (double)rc->baseline_gf_interval) {
double alt_gf_grp_bits = (double)twopass->kf_group_bits *
@@ -1703,7 +1688,7 @@
gf_bits = alt_gf_bits;
}
- // Dont allow a negative value for gf_bits
+ // Don't allow a negative value for gf_bits.
if (gf_bits < 0)
gf_bits = 0;
@@ -1713,27 +1698,27 @@
if (i == 1 ||
(!rc->source_alt_ref_pending &&
cpi->common.frame_type != KEY_FRAME)) {
- // Per frame bit target for this frame
+ // Calculate the per frame bit target for this frame.
vp9_rc_set_frame_target(cpi, gf_bits);
}
}
{
- // Adjust KF group bits and error remaining
+ // Adjust KF group bits and error remaining.
twopass->kf_group_error_left -= (int64_t)gf_group_err;
twopass->kf_group_bits -= twopass->gf_group_bits;
if (twopass->kf_group_bits < 0)
twopass->kf_group_bits = 0;
- // If this is an arf update we want to remove the score for the
- // overlay frame at the end which will usually be very cheap to code.
- // The overlay frame has already in effect been coded so we want to spread
- // the remaining bits amoung the other frames/
+ // If this is an arf update we want to remove the score for the overlay
+ // frame at the end which will usually be very cheap to code.
+ // The overlay frame has already, in effect, been coded so we want to spread
+ // the remaining bits among the other frames.
// For normal GFs remove the score for the GF itself unless this is
// also a key frame in which case it has already been accounted for.
if (rc->source_alt_ref_pending) {
- twopass->gf_group_error_left = (int64_t)gf_group_err - mod_frame_err;
+ twopass->gf_group_error_left = (int64_t)(gf_group_err - mod_frame_err);
} else if (cpi->common.frame_type != KEY_FRAME) {
twopass->gf_group_error_left = (int64_t)(gf_group_err
- gf_first_frame_err);
@@ -1747,7 +1732,7 @@
twopass->gf_group_bits = 0;
// This condition could fail if there are two kfs very close together
- // despite (MIN_GF_INTERVAL) and would cause a divide by 0 in the
+ // despite MIN_GF_INTERVAL and would cause a divide by 0 in the
// calculation of alt_extra_bits.
if (rc->baseline_gf_interval >= 3) {
const int boost = rc->source_alt_ref_pending ? b_boost : rc->gfu_boost;
@@ -1767,7 +1752,7 @@
zero_stats(§ionstats);
reset_fpf_position(twopass, start_pos);
- for (i = 0; i < rc->baseline_gf_interval; i++) {
+ for (i = 0; i < rc->baseline_gf_interval; ++i) {
input_stats(twopass, &next_frame);
accumulate_stats(§ionstats, &next_frame);
}
@@ -1823,20 +1808,18 @@
const FIRSTPASS_STATS *next_frame) {
int is_viable_kf = 0;
- // Does the frame satisfy the primary criteria of a key frame
- // If so, then examine how well it predicts subsequent frames
+ // Does the frame satisfy the primary criteria of a key frame?
+ // If so, then examine how well it predicts subsequent frames.
if ((this_frame->pcnt_second_ref < 0.10) &&
(next_frame->pcnt_second_ref < 0.10) &&
((this_frame->pcnt_inter < 0.05) ||
- (((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .35) &&
+ (((this_frame->pcnt_inter - this_frame->pcnt_neutral) < 0.35) &&
((this_frame->intra_error /
DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
((fabs(last_frame->coded_error - this_frame->coded_error) /
- DOUBLE_DIVIDE_CHECK(this_frame->coded_error) >
- .40) ||
+ DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > 0.40) ||
(fabs(last_frame->intra_error - this_frame->intra_error) /
- DOUBLE_DIVIDE_CHECK(this_frame->intra_error) >
- .40) ||
+ DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > 0.40) ||
((next_frame->intra_error /
DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5))))) {
int i;
@@ -1850,37 +1833,34 @@
local_next_frame = *next_frame;
- // Note the starting file position so we can reset to it
+ // Note the starting file position so we can reset to it.
start_pos = cpi->twopass.stats_in;
- // Examine how well the key frame predicts subsequent frames
- for (i = 0; i < 16; i++) {
+ // 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_DIVIDE_CHECK(local_next_frame.coded_error));
if (next_iiratio > RMAX)
next_iiratio = RMAX;
- // Cumulative effect of decay in prediction quality
+ // Cumulative effect of decay in prediction quality.
if (local_next_frame.pcnt_inter > 0.85)
decay_accumulator *= local_next_frame.pcnt_inter;
else
decay_accumulator *= (0.85 + local_next_frame.pcnt_inter) / 2.0;
- // decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
-
- // Keep a running total
+ // Keep a running total.
boost_score += (decay_accumulator * next_iiratio);
- // Test various breakout clauses
+ // Test various breakout clauses.
if ((local_next_frame.pcnt_inter < 0.05) ||
(next_iiratio < 1.5) ||
(((local_next_frame.pcnt_inter -
local_next_frame.pcnt_neutral) < 0.20) &&
(next_iiratio < 3.0)) ||
((boost_score - old_boost_score) < 3.0) ||
- (local_next_frame.intra_error < 200)
- ) {
+ (local_next_frame.intra_error < 200)) {
break;
}
@@ -1932,18 +1912,18 @@
start_position = twopass->stats_in;
cpi->common.frame_type = KEY_FRAME;
- // is this a forced key frame by interval
+ // Is this a forced key frame by interval.
rc->this_key_frame_forced = rc->next_key_frame_forced;
- // Clear the alt ref active flag as this can never be active on a key frame
+ // Clear the alt ref active flag as this can never be active on a key frame.
rc->source_alt_ref_active = 0;
- // Kf is always a gf so clear frames till next gf counter
+ // KF is always a GF so clear frames till next gf counter.
rc->frames_till_gf_update_due = 0;
rc->frames_to_key = 1;
- // Take a copy of the initial frame details
+ // Take a copy of the initial frame details.
first_frame = *this_frame;
twopass->kf_group_bits = 0; // Total bits available to kf group
@@ -1951,75 +1931,74 @@
kf_mod_err = calculate_modified_err(cpi, this_frame);
- // find the next keyframe
+ // Find the next keyframe.
i = 0;
while (twopass->stats_in < twopass->stats_in_end) {
- // Accumulate kf group error
+ // Accumulate kf group error.
kf_group_err += calculate_modified_err(cpi, this_frame);
- // load a the next frame's stats
+ // Load the next frame's stats.
last_frame = *this_frame;
input_stats(twopass, this_frame);
// Provided that we are not at the end of the file...
if (cpi->oxcf.auto_key &&
lookup_next_frame_stats(twopass, &next_frame) != EOF) {
- // Normal scene cut check
+ // Check for a scene cut.
if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
break;
-
- // How fast is prediction quality decaying
+ // How fast is the prediction quality decaying?
loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame);
// We want to know something about the recent past... rather than
- // as used elsewhere where we are concened with decay in prediction
+ // as used elsewhere where we are concerned with decay in prediction
// quality since the last GF or KF.
recent_loop_decay[i % 8] = loop_decay_rate;
decay_accumulator = 1.0;
- for (j = 0; j < 8; j++)
+ for (j = 0; j < 8; ++j)
decay_accumulator *= recent_loop_decay[j];
// Special check for transition or high motion followed by a
- // to a static scene.
+ // static scene.
if (detect_transition_to_still(cpi, i, cpi->key_frame_frequency - i,
loop_decay_rate, decay_accumulator))
break;
- // Step on to the next frame
- rc->frames_to_key++;
+ // Step on to the next frame.
+ ++rc->frames_to_key;
// If we don't have a real key frame within the next two
- // forcekeyframeevery intervals then break out of the loop.
+ // key_frame_frequency intervals then break out of the loop.
if (rc->frames_to_key >= 2 * (int)cpi->key_frame_frequency)
break;
} else {
- rc->frames_to_key++;
+ ++rc->frames_to_key;
}
- i++;
+ ++i;
}
// If there is a max kf interval set by the user we must obey it.
// We already breakout of the loop above at 2x max.
- // This code centers the extra kf if the actual natural
- // interval is between 1x and 2x
+ // This code centers the extra kf if the actual natural interval
+ // is between 1x and 2x.
if (cpi->oxcf.auto_key &&
rc->frames_to_key > (int)cpi->key_frame_frequency) {
FIRSTPASS_STATS tmp_frame;
rc->frames_to_key /= 2;
- // Copy first frame details
+ // Copy first frame details.
tmp_frame = first_frame;
- // Reset to the start of the group
+ // Reset to the start of the group.
reset_fpf_position(twopass, start_position);
kf_group_err = 0;
- // Rescan to get the correct error data for the forced kf group
- for (i = 0; i < rc->frames_to_key; i++) {
- // Accumulate kf group errors
+ // Rescan to get the correct error data for the forced kf group.
+ for (i = 0; i < rc->frames_to_key; ++i) {
+ // Accumulate kf group errors.
kf_group_err += calculate_modified_err(cpi, &tmp_frame);
// Load the next frame's stats.
@@ -2032,22 +2011,22 @@
rc->next_key_frame_forced = 0;
}
- // Special case for the last key frame of the file
+ // Special case for the last key frame of the file.
if (twopass->stats_in >= twopass->stats_in_end) {
- // Accumulate kf group error
+ // Accumulate kf group error.
kf_group_err += calculate_modified_err(cpi, this_frame);
}
// Calculate the number of bits that should be assigned to the kf group.
if (twopass->bits_left > 0 && twopass->modified_error_left > 0.0) {
- // Max for a single normal frame (not key frame)
+ // Maximum number of bits for a single normal frame (not key frame).
int max_bits = frame_max_bits(cpi);
- // Maximum bits for the kf group
+ // Maximum number of bits allocated to the key frame group.
int64_t max_grp_bits;
// Default allocation based on bits left and relative
- // complexity of the section
+ // complexity of the section.
twopass->kf_group_bits = (int64_t)(twopass->bits_left *
(kf_group_err / twopass->modified_error_left));
@@ -2058,7 +2037,7 @@
} else {
twopass->kf_group_bits = 0;
}
- // Reset the first pass file position
+ // Reset the first pass file position.
reset_fpf_position(twopass, start_position);
// Determine how big to make this keyframe based on how well the subsequent
@@ -2067,7 +2046,7 @@
boost_score = 0.0;
// Scan through the kf group collating various stats.
- for (i = 0; i < rc->frames_to_key; i++) {
+ for (i = 0; i < rc->frames_to_key; ++i) {
double r;
if (EOF == input_stats(twopass, &next_frame))
@@ -2092,7 +2071,7 @@
if (r > RMAX)
r = RMAX;
- // How fast is prediction quality decaying
+ // How fast is prediction quality decaying.
if (!detect_flash(twopass, 0)) {
loop_decay_rate = get_prediction_decay_rate(&cpi->common, &next_frame);
decay_accumulator *= loop_decay_rate;
@@ -2110,7 +2089,7 @@
zero_stats(§ionstats);
reset_fpf_position(twopass, start_position);
- for (i = 0; i < rc->frames_to_key; i++) {
+ for (i = 0; i < rc->frames_to_key; ++i) {
input_stats(twopass, &next_frame);
accumulate_stats(§ionstats, &next_frame);
}
@@ -2121,10 +2100,10 @@
DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
}
- // Reset the first pass file position
+ // Reset the first pass file position.
reset_fpf_position(twopass, start_position);
- // Work out how many bits to allocate for the key frame itself
+ // Work out how many bits to allocate for the key frame itself.
if (1) {
int kf_boost = (int)boost_score;
int allocation_chunks;
@@ -2141,25 +2120,26 @@
rc->kf_boost = kf_boost;
twopass->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
- // We do three calculations for kf size.
- // The first is based on the error score for the whole kf group.
- // The second (optionally) on the key frames own error if this is
- // smaller than the average for the group.
- // The final one insures that the frame receives at least the
- // allocation it would have received based on its own error score vs
- // the error score remaining
- // Special case if the sequence appears almost totaly static
- // In this case we want to spend almost all of the bits on the
- // key frame.
- // cpi->rc.frames_to_key-1 because key frame itself is taken
- // care of by kf_boost.
+ // Key frame size depends on:
+ // (1) the error score for the whole key frame group,
+ // (2) the key frames' own error if this is smaller than the
+ // average for the group (optional),
+ // (3) insuring that the frame receives at least the allocation it would
+ // have received based on its own error score vs the error score
+ // remaining.
+ // Special case:
+ // If the sequence appears almost totally static we want to spend almost
+ // all of the bits on the key frame.
+ //
+ // We use (cpi->rc.frames_to_key - 1) below because the key frame itself is
+ // taken care of by kf_boost.
if (zero_motion_accumulator >= 0.99) {
allocation_chunks = ((rc->frames_to_key - 1) * 10) + kf_boost;
} else {
allocation_chunks = ((rc->frames_to_key - 1) * 100) + kf_boost;
}
- // Prevent overflow
+ // Prevent overflow.
if (kf_boost > 1028) {
int divisor = kf_boost >> 10;
kf_boost /= divisor;
@@ -2169,7 +2149,7 @@
twopass->kf_group_bits = (twopass->kf_group_bits < 0) ? 0
: twopass->kf_group_bits;
- // Calculate the number of bits to be spent on the key frame
+ // Calculate the number of bits to be spent on the key frame.
twopass->kf_bits = (int)((double)kf_boost *
((double)twopass->kf_group_bits / allocation_chunks));
@@ -2188,9 +2168,9 @@
if (twopass->kf_bits > alt_kf_bits)
twopass->kf_bits = alt_kf_bits;
} else {
- // Else if it is much harder than other frames in the group make sure
- // it at least receives an allocation in keeping with its relative
- // error score
+ // Else if it is much harder than other frames in the group make sure
+ // it at least receives an allocation in keeping with its relative
+ // error score.
alt_kf_bits = (int)((double)twopass->bits_left * (kf_mod_err /
DOUBLE_DIVIDE_CHECK(twopass->modified_error_left)));
@@ -2203,7 +2183,7 @@
vp9_rc_set_frame_target(cpi, twopass->kf_bits);
}
- // Note the total error score of the kf group minus the key frame itself
+ // Note the total error score of the kf group minus the key frame itself.
twopass->kf_group_error_left = (int)(kf_group_err - kf_mod_err);
// Adjust the count of total modified error left.
@@ -2221,7 +2201,7 @@
} else {
cm->frame_type = INTER_FRAME;
}
- // Do not use periodic key frames
+ // Do not use periodic key frames.
cpi->rc.frames_to_key = INT_MAX;
}
@@ -2260,13 +2240,6 @@
twopass->active_worst_quality = tmp_q;
rc->ni_av_qi = tmp_q;
rc->avg_q = vp9_convert_qindex_to_q(tmp_q);
-
- // Limit the maxq value returned subsequently.
- // This increases the risk of overspend or underspend if the initial
- // estimate for the clip is bad, but helps prevent excessive
- // variation in Q, especially near the end of a clip
- // where for example a small overspend may cause Q to crash
- // adjust_maxq_qrange(cpi);
}
vp9_zero(this_frame);
if (EOF == input_stats(twopass, &this_frame))
@@ -2275,19 +2248,19 @@
this_frame_intra_error = this_frame.intra_error;
this_frame_coded_error = this_frame.coded_error;
- // keyframe and section processing !
+ // Keyframe and section processing.
if (rc->frames_to_key == 0 ||
(cm->frame_flags & FRAMEFLAGS_KEY)) {
- // Define next KF group and assign bits to it
+ // Define next KF group and assign bits to it.
this_frame_copy = this_frame;
find_next_key_frame(cpi, &this_frame_copy);
} else {
cm->frame_type = INTER_FRAME;
}
- // Is this a GF / ARF (Note that a KF is always also a GF)
+ // Is this frame a GF / ARF? (Note: a key frame is always also a GF).
if (rc->frames_till_gf_update_due == 0) {
- // Define next gf group and assign bits to it
+ // Define next gf group and assign bits to it.
this_frame_copy = this_frame;
#if CONFIG_MULTIPLE_ARF
@@ -2302,7 +2275,8 @@
if (twopass->gf_zeromotion_pct > 995) {
// As long as max_thresh for encode breakout is small enough, it is ok
- // to enable it for show frame, i.e. set allow_encode_breakout to 2.
+ // to enable it for show frame, i.e. set allow_encode_breakout to
+ // ENCODE_BREAKOUT_LIMITED.
if (!cm->show_frame)
cpi->allow_encode_breakout = ENCODE_BREAKOUT_DISABLED;
else
@@ -2312,8 +2286,8 @@
rc->frames_till_gf_update_due = rc->baseline_gf_interval;
cpi->refresh_golden_frame = 1;
} else {
- // Otherwise this is an ordinary frame
- // Assign bits from those allocated to the GF group
+ // Otherwise this is an ordinary frame.
+ // Assign bits from those allocated to the GF group.
this_frame_copy = this_frame;
assign_std_frame_bits(cpi, &this_frame_copy);
}
@@ -2335,7 +2309,7 @@
target = vp9_rc_clamp_pframe_target_size(cpi, rc->this_frame_target);
vp9_rc_set_frame_target(cpi, target);
- // Update the total stats remaining structure
+ // Update the total stats remaining structure.
subtract_stats(&twopass->total_left_stats, &this_frame);
}
@@ -2345,7 +2319,7 @@
#else
cpi->twopass.bits_left -= 8 * bytes_used;
// Update bits left to the kf and gf groups to account for overshoot or
- // undershoot on these frames
+ // undershoot on these frames.
if (cm->frame_type == KEY_FRAME) {
cpi->twopass.kf_group_bits += cpi->rc.this_frame_target -
cpi->rc.projected_frame_size;
diff --git a/vp9/encoder/vp9_mcomp.c b/vp9/encoder/vp9_mcomp.c
index f5c0e9b..94e49bd 100644
--- a/vp9/encoder/vp9_mcomp.c
+++ b/vp9/encoder/vp9_mcomp.c
@@ -871,10 +871,10 @@
MV this_mv;
- int bestsad = INT_MAX;
+ unsigned int bestsad = INT_MAX;
int ref_row, ref_col;
- int thissad;
+ unsigned int thissad;
const MV fcenter_mv = {center_mv->row >> 3, center_mv->col >> 3};
const int *mvjsadcost = x->nmvjointsadcost;
diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c
index 84a0e60..887480a 100644
--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -218,8 +218,8 @@
// Computes a q delta (in "q index" terms) to get from a starting q value
// to a value that should equate to thegiven rate ratio.
-int vp9_compute_qdelta_by_rate(VP9_COMP *cpi,
- double base_q_index, double rate_target_ratio) {
+static int compute_qdelta_by_rate(VP9_COMP *cpi, int base_q_index,
+ double rate_target_ratio) {
int i;
int base_bits_per_mb;
int target_bits_per_mb;
@@ -233,7 +233,7 @@
base_q_index, 1.0);
// Find the target bits per mb based on the base value and given ratio.
- target_bits_per_mb = rate_target_ratio * base_bits_per_mb;
+ target_bits_per_mb = (int)(rate_target_ratio * base_bits_per_mb);
// Convert the q target to an index
for (i = cpi->rc.best_quality; i < cpi->rc.worst_quality; i++) {
@@ -278,9 +278,8 @@
// Use some of the segments for in frame Q adjustment
for (segment = 1; segment < 2; segment++) {
- qindex_delta =
- vp9_compute_qdelta_by_rate(cpi, cm->base_qindex,
- in_frame_q_adj_ratio[segment]);
+ qindex_delta = compute_qdelta_by_rate(cpi, cm->base_qindex,
+ in_frame_q_adj_ratio[segment]);
vp9_enable_segfeature(seg, segment, SEG_LVL_ALT_Q);
vp9_set_segdata(seg, segment, SEG_LVL_ALT_Q, qindex_delta);
}
@@ -1112,7 +1111,7 @@
void vp9_new_framerate(VP9_COMP *cpi, double framerate) {
VP9_COMMON *const cm = &cpi->common;
- int64_t vbr_max_bits;
+ int vbr_max_bits;
if (framerate < 0.1)
framerate = 30;
@@ -1136,10 +1135,10 @@
// be acheived because of a user specificed max q (e.g. when the user
// specifies lossless encode.
//
- vbr_max_bits = ((int64_t)cpi->rc.av_per_frame_bandwidth *
- (int64_t)cpi->oxcf.two_pass_vbrmax_section) / 100;
+ vbr_max_bits = (int)(((int64_t)cpi->rc.av_per_frame_bandwidth *
+ cpi->oxcf.two_pass_vbrmax_section) / 100);
cpi->rc.max_frame_bandwidth =
- MAX(MAX((cm->MBs * MAX_MB_RATE), MAXRATE_1080P), vbr_max_bits);
+ MAX(MAX((cm->MBs * MAX_MB_RATE), MAXRATE_1080P), vbr_max_bits);
// Set Maximum gf/arf interval
cpi->rc.max_gf_interval = 16;
@@ -1160,7 +1159,7 @@
cpi->rc.max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
}
-static int64_t rescale(int val, int64_t num, int denom) {
+static int64_t rescale(int64_t val, int64_t num, int denom) {
int64_t llnum = num;
int64_t llden = denom;
int64_t llval = val;
@@ -1213,9 +1212,12 @@
lc->target_bandwidth = oxcf->ts_target_bitrate[temporal_layer] * 1000;
bitrate_alloc = (float)lc->target_bandwidth / (float)target_bandwidth;
// Update buffer-related quantities.
- lc->starting_buffer_level = oxcf->starting_buffer_level * bitrate_alloc;
- lc->optimal_buffer_level = oxcf->optimal_buffer_level * bitrate_alloc;
- lc->maximum_buffer_size = oxcf->maximum_buffer_size * bitrate_alloc;
+ lc->starting_buffer_level =
+ (int64_t)(oxcf->starting_buffer_level * bitrate_alloc);
+ lc->optimal_buffer_level =
+ (int64_t)(oxcf->optimal_buffer_level * bitrate_alloc);
+ lc->maximum_buffer_size =
+ (int64_t)(oxcf->maximum_buffer_size * bitrate_alloc);
lrc->bits_off_target = MIN(lrc->bits_off_target, lc->maximum_buffer_size);
lrc->buffer_level = MIN(lrc->buffer_level, lc->maximum_buffer_size);
// Update framerate-related quantities.
@@ -1247,8 +1249,8 @@
int prev_layer_target_bandwidth =
oxcf->ts_target_bitrate[temporal_layer - 1] * 1000;
lc->avg_frame_size =
- (int)(lc->target_bandwidth - prev_layer_target_bandwidth) /
- (lc->framerate - prev_layer_framerate);
+ (int)((lc->target_bandwidth - prev_layer_target_bandwidth) /
+ (lc->framerate - prev_layer_framerate));
}
}
@@ -1276,7 +1278,7 @@
int temporal_layer = cpi->svc.temporal_layer_id;
LAYER_CONTEXT *lc = &cpi->svc.layer_context[temporal_layer];
lc->rc = cpi->rc;
- lc->target_bandwidth = cpi->oxcf.target_bandwidth;
+ lc->target_bandwidth = (int)cpi->oxcf.target_bandwidth;
lc->starting_buffer_level = cpi->oxcf.starting_buffer_level;
lc->optimal_buffer_level = cpi->oxcf.optimal_buffer_level;
lc->maximum_buffer_size = cpi->oxcf.maximum_buffer_size;
@@ -1493,10 +1495,10 @@
if (cpi->svc.number_temporal_layers > 1 &&
cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {
- update_layer_context_change_config(cpi, cpi->oxcf.target_bandwidth);
+ update_layer_context_change_config(cpi, (int)cpi->oxcf.target_bandwidth);
}
- cpi->speed = cpi->oxcf.cpu_used;
+ cpi->speed = abs(cpi->oxcf.cpu_used);
if (cpi->oxcf.lag_in_frames == 0) {
// Force allow_lag to 0 if lag_in_frames is 0.
@@ -1570,6 +1572,7 @@
int num_pix = num_4x4_blk << 4;
int i, k;
ctx->num_4x4_blk = num_4x4_blk;
+
CHECK_MEM_ERROR(cm, ctx->zcoeff_blk,
vpx_calloc(num_4x4_blk, sizeof(uint8_t)));
for (i = 0; i < MAX_MB_PLANE; ++i) {
@@ -1613,7 +1616,6 @@
VP9_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->mb;
-
for (i = 0; i < BLOCK_SIZES; ++i) {
const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
const int num_4x4_h = num_4x4_blocks_high_lookup[i];
@@ -2031,10 +2033,12 @@
/ time_encoded;
if (cpi->b_calculate_psnr) {
- const double total_psnr = vp9_mse2psnr(cpi->total_samples, 255.0,
- cpi->total_sq_error);
- const double totalp_psnr = vp9_mse2psnr(cpi->totalp_samples, 255.0,
- cpi->totalp_sq_error);
+ const double total_psnr =
+ vp9_mse2psnr((double)cpi->total_samples, 255.0,
+ (double)cpi->total_sq_error);
+ const double totalp_psnr =
+ vp9_mse2psnr((double)cpi->totalp_samples, 255.0,
+ (double)cpi->totalp_sq_error);
const double total_ssim = 100 * pow(cpi->summed_quality /
cpi->summed_weights, 8.0);
const double totalp_ssim = 100 * pow(cpi->summedp_quality /
@@ -2210,12 +2214,12 @@
const int w = widths[i];
const int h = heights[i];
const uint32_t samples = w * h;
- const double sse = calc_plane_error(a_planes[i], a_strides[i],
- b_planes[i], b_strides[i],
- w, h);
+ const uint64_t sse = calc_plane_error(a_planes[i], a_strides[i],
+ b_planes[i], b_strides[i],
+ w, h);
psnr->sse[1 + i] = sse;
psnr->samples[1 + i] = samples;
- psnr->psnr[1 + i] = vp9_mse2psnr(samples, 255.0, sse);
+ psnr->psnr[1 + i] = vp9_mse2psnr(samples, 255.0, (double) sse);
total_sse += sse;
total_samples += samples;
@@ -2223,7 +2227,7 @@
psnr->sse[0] = total_sse;
psnr->samples[0] = total_samples;
- psnr->psnr[0] = vp9_mse2psnr(total_samples, 255.0, total_sse);
+ psnr->psnr[0] = vp9_mse2psnr((double)total_samples, 255.0, (double)total_sse);
}
static void generate_psnr_packet(VP9_COMP *cpi) {
@@ -2894,7 +2898,7 @@
if (!cpi->sf.use_pick_mode)
vp9_pack_bitstream(cpi, dest, size);
- cpi->rc.projected_frame_size = (*size) << 3;
+ cpi->rc.projected_frame_size = (int)(*size) << 3;
vp9_restore_coding_context(cpi);
if (frame_over_shoot_limit == 0)
@@ -3764,7 +3768,7 @@
#if CONFIG_INTERNAL_STATS
if (cpi->pass != 1) {
- cpi->bytes += *size;
+ cpi->bytes += (int)(*size);
if (cm->show_frame) {
cpi->count++;
diff --git a/vp9/encoder/vp9_onyx_int.h b/vp9/encoder/vp9_onyx_int.h
index 1ab1814..7c0135e 100644
--- a/vp9/encoder/vp9_onyx_int.h
+++ b/vp9/encoder/vp9_onyx_int.h
@@ -445,7 +445,7 @@
YV12_BUFFER_CONFIG *un_scaled_source;
YV12_BUFFER_CONFIG scaled_source;
- unsigned int key_frame_frequency;
+ int key_frame_frequency;
int gold_is_last; // gold same as last frame ( short circuit gold searches)
int alt_is_last; // Alt same as last ( short circuit altref search)
@@ -488,9 +488,6 @@
unsigned int mode_chosen_counts[MAX_MODES];
unsigned int sub8x8_mode_chosen_counts[MAX_REFS];
- int64_t mode_skip_mask;
- int ref_frame_mask;
- int set_ref_frame_mask;
int rd_threshes[MAX_SEGMENTS][BLOCK_SIZES][MAX_MODES];
int rd_thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c
index 48948fc..945fa81 100644
--- a/vp9/encoder/vp9_pickmode.c
+++ b/vp9/encoder/vp9_pickmode.c
@@ -127,11 +127,52 @@
// calculate the bit cost on motion vector
*rate_mv = vp9_mv_bit_cost(&tmp_mv->as_mv, &ref_mv.as_mv,
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
-
-
return bestsme;
}
+static void sub_pixel_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
+ const TileInfo *const tile,
+ BLOCK_SIZE bsize, int mi_row, int mi_col,
+ int_mv *tmp_mv) {
+ MACROBLOCKD *xd = &x->e_mbd;
+ MB_MODE_INFO *mbmi = &xd->mi_8x8[0]->mbmi;
+ struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0}};
+ int ref = mbmi->ref_frame[0];
+ int_mv ref_mv = mbmi->ref_mvs[ref][0];
+ int dis;
+
+ const YV12_BUFFER_CONFIG *scaled_ref_frame = vp9_get_scaled_ref_frame(cpi,
+ ref);
+ if (scaled_ref_frame) {
+ int i;
+ // Swap out the reference frame for a version that's been scaled to
+ // match the resolution of the current frame, allowing the existing
+ // motion search code to be used without additional modifications.
+ for (i = 0; i < MAX_MB_PLANE; i++)
+ backup_yv12[i] = xd->plane[i].pre[0];
+
+ setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL);
+ }
+
+ tmp_mv->as_mv.col >>= 3;
+ tmp_mv->as_mv.row >>= 3;
+
+ cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv.as_mv,
+ cpi->common.allow_high_precision_mv,
+ x->errorperbit,
+ &cpi->fn_ptr[bsize],
+ cpi->sf.subpel_force_stop,
+ cpi->sf.subpel_iters_per_step,
+ x->nmvjointcost, x->mvcost,
+ &dis, &x->pred_sse[ref]);
+
+ if (scaled_ref_frame) {
+ int i;
+ for (i = 0; i < MAX_MB_PLANE; i++)
+ xd->plane[i].pre[0] = backup_yv12[i];
+ }
+}
+
// TODO(jingning) placeholder for inter-frame non-RD mode decision.
// this needs various further optimizations. to be continued..
int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
@@ -151,7 +192,7 @@
VP9_ALT_FLAG };
int64_t best_rd = INT64_MAX;
int64_t this_rd;
- int64_t cost[4]= { 0, 100, 150, 205 };
+ int cost[4]= { 0, 100, 150, 205 };
x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
@@ -161,6 +202,7 @@
// initialize mode decisions
*returnrate = INT_MAX;
+ *returndistortion = INT64_MAX;
vpx_memset(mbmi, 0, sizeof(MB_MODE_INFO));
mbmi->sb_type = bsize;
mbmi->ref_frame[0] = NONE;
@@ -200,9 +242,6 @@
int64_t dist;
if (this_mode == NEWMV) {
- if (this_rd < 300)
- continue;
-
x->mode_sad[ref_frame][INTER_OFFSET(NEWMV)] =
full_pixel_motion_search(cpi, x, tile, bsize, mi_row, mi_col,
&frame_mv[NEWMV][ref_frame], &rate_mv);
@@ -226,6 +265,13 @@
}
// TODO(jingning) sub-pixel motion search, if NEWMV is chosen
+ if (mbmi->mode == NEWMV) {
+ ref_frame = mbmi->ref_frame[0];
+ sub_pixel_motion_search(cpi, x, tile, bsize, mi_row, mi_col,
+ &frame_mv[NEWMV][ref_frame]);
+ mbmi->mv[0].as_int = frame_mv[NEWMV][ref_frame].as_int;
+ xd->mi_8x8[0]->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int;
+ }
// TODO(jingning) intra prediction search, if the best SAD is above a certain
// threshold.
diff --git a/vp9/encoder/vp9_quantize.c b/vp9/encoder/vp9_quantize.c
index 862573f..372c362 100644
--- a/vp9/encoder/vp9_quantize.c
+++ b/vp9/encoder/vp9_quantize.c
@@ -26,7 +26,7 @@
const int16_t *dequant_ptr,
int zbin_oq_value, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
- int i, non_zero_count = count, eob = -1;
+ int i, non_zero_count = (int)count, eob = -1;
const int zbins[2] = { zbin_ptr[0] + zbin_oq_value,
zbin_ptr[1] + zbin_oq_value };
const int nzbins[2] = { zbins[0] * -1,
@@ -37,7 +37,7 @@
if (!skip_block) {
// Pre-scan pass
- for (i = count - 1; i >= 0; i--) {
+ for (i = (int)count - 1; i >= 0; i--) {
const int rc = scan[i];
const int coeff = coeff_ptr[rc];
diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c
index bc2c3a6..a556063 100644
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -500,9 +500,9 @@
const VP9_CONFIG *oxcf = &cpi->oxcf;
const RATE_CONTROL *rc = &cpi->rc;
// Buffer level below which we push active_worst to worst_quality.
- int critical_level = oxcf->optimal_buffer_level >> 2;
+ int64_t critical_level = oxcf->optimal_buffer_level >> 2;
+ int64_t buff_lvl_step = 0;
int adjustment = 0;
- int buff_lvl_step = 0;
int active_worst_quality;
if (cpi->common.frame_type == KEY_FRAME)
return rc->worst_quality;
@@ -517,8 +517,8 @@
// Maximum limit for down adjustment, ~30%.
int max_adjustment_down = active_worst_quality / 3;
if (max_adjustment_down) {
- buff_lvl_step = (int)((oxcf->maximum_buffer_size -
- oxcf->optimal_buffer_level) / max_adjustment_down);
+ buff_lvl_step = ((oxcf->maximum_buffer_size -
+ oxcf->optimal_buffer_level) / max_adjustment_down);
if (buff_lvl_step)
adjustment = (int)((rc->buffer_level - oxcf->optimal_buffer_level) /
buff_lvl_step);
@@ -529,9 +529,10 @@
if (critical_level) {
buff_lvl_step = (oxcf->optimal_buffer_level - critical_level);
if (buff_lvl_step) {
- adjustment = (rc->worst_quality - rc->avg_frame_qindex[INTER_FRAME]) *
- (oxcf->optimal_buffer_level - rc->buffer_level) /
- buff_lvl_step;
+ adjustment =
+ (int)((rc->worst_quality - rc->avg_frame_qindex[INTER_FRAME]) *
+ (oxcf->optimal_buffer_level - rc->buffer_level) /
+ buff_lvl_step);
}
active_worst_quality = rc->avg_frame_qindex[INTER_FRAME] + adjustment;
}
@@ -1150,7 +1151,7 @@
cm->last_frame_type = cm->frame_type;
// Update rate control heuristics
- rc->projected_frame_size = (bytes_used << 3);
+ rc->projected_frame_size = (int)(bytes_used << 3);
// Post encode loop adjustment of Q prediction.
vp9_rc_update_rate_correction_factors(
@@ -1309,7 +1310,7 @@
const VP9_CONFIG *oxcf = &cpi->oxcf;
const RATE_CONTROL *rc = &cpi->rc;
const int64_t diff = oxcf->optimal_buffer_level - rc->buffer_level;
- const int one_pct_bits = 1 + oxcf->optimal_buffer_level / 100;
+ const int64_t one_pct_bits = 1 + oxcf->optimal_buffer_level / 100;
int min_frame_target = MAX(rc->av_per_frame_bandwidth >> 4,
FRAME_OVERHEAD_BITS);
int target = rc->av_per_frame_bandwidth;
@@ -1325,11 +1326,11 @@
}
if (diff > 0) {
// Lower the target bandwidth for this frame.
- const int pct_low = MIN(diff / one_pct_bits, oxcf->under_shoot_pct);
+ const int pct_low = (int)MIN(diff / one_pct_bits, oxcf->under_shoot_pct);
target -= (target * pct_low) / 200;
} else if (diff < 0) {
// Increase the target bandwidth for this frame.
- const int pct_high = MIN(-diff / one_pct_bits, oxcf->over_shoot_pct);
+ const int pct_high = (int)MIN(-diff / one_pct_bits, oxcf->over_shoot_pct);
target += (target * pct_high) / 200;
}
return MAX(min_frame_target, target);
@@ -1337,9 +1338,11 @@
static int calc_iframe_target_size_one_pass_cbr(const VP9_COMP *cpi) {
const RATE_CONTROL *rc = &cpi->rc;
+ int target;
if (cpi->common.current_video_frame == 0) {
- return cpi->oxcf.starting_buffer_level / 2;
+ target = ((cpi->oxcf.starting_buffer_level / 2) > INT_MAX)
+ ? INT_MAX : (int)(cpi->oxcf.starting_buffer_level / 2);
} else {
const int initial_boost = 32;
int kf_boost = MAX(initial_boost, (int)(2 * cpi->output_framerate - 16));
@@ -1347,8 +1350,9 @@
kf_boost = (int)(kf_boost * rc->frames_since_key /
(cpi->output_framerate / 2));
}
- return ((16 + kf_boost) * rc->av_per_frame_bandwidth) >> 4;
+ target = ((16 + kf_boost) * rc->av_per_frame_bandwidth) >> 4;
}
+ return vp9_rc_clamp_iframe_target_size(cpi, target);
}
void vp9_rc_get_svc_params(VP9_COMP *cpi) {
diff --git a/vp9/encoder/vp9_ratectrl.h b/vp9/encoder/vp9_ratectrl.h
index 551b6c3..5dbc7d1 100644
--- a/vp9/encoder/vp9_ratectrl.h
+++ b/vp9/encoder/vp9_ratectrl.h
@@ -34,17 +34,17 @@
double key_frame_rate_correction_factor;
double gf_rate_correction_factor;
- unsigned int frames_since_golden;
- unsigned int frames_till_gf_update_due; // Count down till next GF
- unsigned int max_gf_interval;
- unsigned int baseline_gf_interval;
- unsigned int frames_to_key;
- unsigned int frames_since_key;
- unsigned int this_key_frame_forced;
- unsigned int next_key_frame_forced;
- unsigned int source_alt_ref_pending;
- unsigned int source_alt_ref_active;
- unsigned int is_src_frame_alt_ref;
+ int frames_since_golden;
+ int frames_till_gf_update_due;
+ int max_gf_interval;
+ int baseline_gf_interval;
+ int frames_to_key;
+ int frames_since_key;
+ int this_key_frame_forced;
+ int next_key_frame_forced;
+ int source_alt_ref_pending;
+ int source_alt_ref_active;
+ int is_src_frame_alt_ref;
int av_per_frame_bandwidth; // Average frame size target for clip
int min_frame_bandwidth; // Minimum allocation used for any frame
@@ -57,8 +57,8 @@
double tot_q;
double avg_q;
- int buffer_level;
- int bits_off_target;
+ int64_t buffer_level;
+ int64_t bits_off_target;
int decimation_factor;
int decimation_count;
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index f0a861d..a3e879b 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -415,9 +415,10 @@
*dist = 0;
} else {
int d_q10, r_q10;
- uint64_t xsq_q10_64 =
+ const uint64_t xsq_q10_64 =
((((uint64_t)qstep * qstep * n) << 10) + (var >> 1)) / var;
- int xsq_q10 = xsq_q10_64 > MAX_XSQ_Q10 ? MAX_XSQ_Q10 : xsq_q10_64;
+ const int xsq_q10 = xsq_q10_64 > MAX_XSQ_Q10 ?
+ MAX_XSQ_Q10 : (int)xsq_q10_64;
model_rd_norm(xsq_q10, &r_q10, &d_q10);
*rate = (n * r_q10 + 2) >> 2;
*dist = (var * (int64_t)d_q10 + 512) >> 10;
@@ -444,8 +445,21 @@
if (i == 0)
x->pred_sse[ref] = sse;
- if (cpi->sf.use_pick_mode) {
- dist_sum += (int)sse;
+
+ // Fast approximate the modelling function.
+ if (cpi->speed > 4) {
+ int rate;
+ int64_t dist;
+ int64_t square_error = sse;
+ int quantizer = (pd->dequant[1] >> 3);
+
+ if ( quantizer < 120)
+ rate = (square_error * (280-quantizer) )>> 8;
+ else
+ rate = 0;
+ dist = (square_error * quantizer) >> 8;
+ rate_sum += rate;
+ dist_sum += dist;
} else {
int rate;
int64_t dist;
@@ -844,6 +858,11 @@
}
}
+static int64_t scaled_rd_cost(int rdmult, int rddiv,
+ int rate, int64_t dist, double scale) {
+ return (int64_t) (RDCOST(rdmult, rddiv, rate, dist) * scale);
+}
+
static void choose_txfm_size_from_modelrd(VP9_COMP *cpi, MACROBLOCK *x,
int (*r)[2], int *rate,
int64_t *d, int64_t *distortion,
@@ -881,10 +900,13 @@
r[n][1] += vp9_cost_one(tx_probs[m]);
}
if (s[n]) {
- rd[n][0] = rd[n][1] = RDCOST(x->rdmult, x->rddiv, s1, d[n]) * scale;
+ rd[n][0] = rd[n][1] = scaled_rd_cost(x->rdmult, x->rddiv, s1, d[n],
+ scale);
} else {
- rd[n][0] = RDCOST(x->rdmult, x->rddiv, r[n][0] + s0, d[n]) * scale;
- rd[n][1] = RDCOST(x->rdmult, x->rddiv, r[n][1] + s0, d[n]) * scale;
+ rd[n][0] = scaled_rd_cost(x->rdmult, x->rddiv, r[n][0] + s0, d[n],
+ scale);
+ rd[n][1] = scaled_rd_cost(x->rdmult, x->rddiv, r[n][1] + s0, d[n],
+ scale);
}
if (rd[n][1] < best_rd) {
best_rd = rd[n][1];
@@ -2905,8 +2927,8 @@
const unsigned int max_thresh = (cpi->allow_encode_breakout ==
ENCODE_BREAKOUT_LIMITED) ? 128 : 36000;
// The encode_breakout input
- const unsigned int min_thresh = ((x->encode_breakout << 4) > max_thresh) ?
- max_thresh : (x->encode_breakout << 4);
+ const unsigned int min_thresh =
+ MIN(((unsigned int)x->encode_breakout << 4), max_thresh);
// Calculate threshold according to dequant value.
thresh_ac = (xd->plane[0].dequant[1] * xd->plane[0].dequant[1]) / 9;
@@ -3136,6 +3158,8 @@
const int bws = num_8x8_blocks_wide_lookup[bsize] / 2;
const int bhs = num_8x8_blocks_high_lookup[bsize] / 2;
int best_skip2 = 0;
+ int ref_frame_mask = 0;
+ int mode_skip_mask = 0;
x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
@@ -3169,13 +3193,12 @@
frame_mv[ZEROMV][ref_frame].as_int = 0;
}
- cpi->ref_frame_mask = 0;
for (ref_frame = LAST_FRAME;
ref_frame <= ALTREF_FRAME && cpi->sf.reference_masking; ++ref_frame) {
int i;
for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
if ((x->pred_mv_sad[ref_frame] >> 2) > x->pred_mv_sad[i]) {
- cpi->ref_frame_mask |= (1 << ref_frame);
+ ref_frame_mask |= (1 << ref_frame);
break;
}
}
@@ -3209,28 +3232,28 @@
if (mode_index == (cpi->sf.mode_skip_start + 1)) {
switch (vp9_mode_order[best_mode_index].ref_frame[0]) {
case INTRA_FRAME:
- cpi->mode_skip_mask = 0;
+ mode_skip_mask = 0;
break;
case LAST_FRAME:
- cpi->mode_skip_mask = LAST_FRAME_MODE_MASK;
+ mode_skip_mask = LAST_FRAME_MODE_MASK;
break;
case GOLDEN_FRAME:
- cpi->mode_skip_mask = GOLDEN_FRAME_MODE_MASK;
+ mode_skip_mask = GOLDEN_FRAME_MODE_MASK;
break;
case ALTREF_FRAME:
- cpi->mode_skip_mask = ALT_REF_MODE_MASK;
+ mode_skip_mask = ALT_REF_MODE_MASK;
break;
case NONE:
case MAX_REF_FRAMES:
assert(0 && "Invalid Reference frame");
}
}
- if (cpi->mode_skip_mask & ((int64_t)1 << mode_index))
+ if (mode_skip_mask & (1 << mode_index))
continue;
}
// Skip if the current reference frame has been masked off
- if (cpi->ref_frame_mask & (1 << ref_frame) && this_mode != NEWMV)
+ if (ref_frame_mask & (1 << ref_frame) && this_mode != NEWMV)
continue;
// Test best rd so far against threshold for trying this mode.
@@ -3755,6 +3778,8 @@
int_mv seg_mvs[4][MAX_REF_FRAMES];
b_mode_info best_bmodes[4];
int best_skip2 = 0;
+ int ref_frame_mask = 0;
+ int mode_skip_mask = 0;
x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
vpx_memset(x->zcoeff_blk[TX_4X4], 0, 4);
@@ -3790,13 +3815,12 @@
frame_mv[ZEROMV][ref_frame].as_int = 0;
}
- cpi->ref_frame_mask = 0;
for (ref_frame = LAST_FRAME;
ref_frame <= ALTREF_FRAME && cpi->sf.reference_masking; ++ref_frame) {
int i;
for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) {
if ((x->pred_mv_sad[ref_frame] >> 1) > x->pred_mv_sad[i]) {
- cpi->ref_frame_mask |= (1 << ref_frame);
+ ref_frame_mask |= (1 << ref_frame);
break;
}
}
@@ -3829,23 +3853,23 @@
if (mode_index == 3) {
switch (vp9_ref_order[best_mode_index].ref_frame[0]) {
case INTRA_FRAME:
- cpi->mode_skip_mask = 0;
+ mode_skip_mask = 0;
break;
case LAST_FRAME:
- cpi->mode_skip_mask = 0x0010;
+ mode_skip_mask = 0x0010;
break;
case GOLDEN_FRAME:
- cpi->mode_skip_mask = 0x0008;
+ mode_skip_mask = 0x0008;
break;
case ALTREF_FRAME:
- cpi->mode_skip_mask = 0x0000;
+ mode_skip_mask = 0x0000;
break;
case NONE:
case MAX_REF_FRAMES:
assert(0 && "Invalid Reference frame");
}
}
- if (cpi->mode_skip_mask & ((int64_t)1 << mode_index))
+ if (mode_skip_mask & (1 << mode_index))
continue;
}
diff --git a/vp9/encoder/vp9_tokenize.c b/vp9/encoder/vp9_tokenize.c
index 510ef78..2be00ff 100644
--- a/vp9/encoder/vp9_tokenize.c
+++ b/vp9/encoder/vp9_tokenize.c
@@ -214,7 +214,7 @@
TOKENEXTRA *t = *tp; /* store tokens starting here */
int eob = p->eobs[block];
const PLANE_TYPE type = pd->plane_type;
- const int16_t *qcoeff_ptr = BLOCK_OFFSET(p->qcoeff, block);
+ const int16_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block);
const int segment_id = mbmi->segment_id;
const int16_t *scan, *nb;
const scan_order *so;
@@ -241,7 +241,7 @@
while (c < eob) {
int v = 0;
int skip_eob = 0;
- v = qcoeff_ptr[scan[c]];
+ v = qcoeff[scan[c]];
while (!v) {
add_token_no_extra(&t, coef_probs[band[c]][pt], ZERO_TOKEN, skip_eob,
@@ -252,12 +252,13 @@
token_cache[scan[c]] = 0;
++c;
pt = get_coef_context(nb, token_cache, c);
- v = qcoeff_ptr[scan[c]];
+ v = qcoeff[scan[c]];
}
add_token(&t, coef_probs[band[c]][pt],
vp9_dct_value_tokens_ptr[v].extra,
- vp9_dct_value_tokens_ptr[v].token, skip_eob,
+ (uint8_t)vp9_dct_value_tokens_ptr[v].token,
+ (uint8_t)skip_eob,
counts[band[c]][pt]);
eob_branch[band[c]][pt] += !skip_eob;
diff --git a/vp9/encoder/vp9_vaq.c b/vp9/encoder/vp9_vaq.c
index acd7c41..896cd2c 100644
--- a/vp9/encoder/vp9_vaq.c
+++ b/vp9/encoder/vp9_vaq.c
@@ -75,9 +75,9 @@
void vp9_vaq_frame_setup(VP9_COMP *cpi) {
VP9_COMMON *cm = &cpi->common;
struct segmentation *seg = &cm->seg;
- int base_q = vp9_convert_qindex_to_q(cm->base_qindex);
- int base_rdmult = vp9_compute_rd_mult(cpi, cm->base_qindex +
- cm->y_dc_delta_q);
+ const double base_q = vp9_convert_qindex_to_q(cm->base_qindex);
+ const int base_rdmult = vp9_compute_rd_mult(cpi, cm->base_qindex +
+ cm->y_dc_delta_q);
int i;
if (cm->frame_type == KEY_FRAME ||
@@ -143,9 +143,6 @@
vp9_clear_system_state(); // __asm emms;
- // if (var <= 1000)
- // return 0;
-
- energy = 0.9*(logf(var + 1) - 10.0);
+ energy = 0.9 * (log(var + 1.0) - 10.0);
return clamp(round(energy), ENERGY_MIN, ENERGY_MAX);
}
diff --git a/vp9/encoder/vp9_write_bit_buffer.h b/vp9/encoder/vp9_write_bit_buffer.h
index 5958b48..1795e05 100644
--- a/vp9/encoder/vp9_write_bit_buffer.h
+++ b/vp9/encoder/vp9_write_bit_buffer.h
@@ -29,7 +29,7 @@
}
static void vp9_wb_write_bit(struct vp9_write_bit_buffer *wb, int bit) {
- const int off = wb->bit_offset;
+ const int off = (int)wb->bit_offset;
const int p = off / CHAR_BIT;
const int q = CHAR_BIT - 1 - off % CHAR_BIT;
if (q == CHAR_BIT -1) {
diff --git a/vp9/encoder/x86/vp9_dct_avx2.c b/vp9/encoder/x86/vp9_dct_avx2.c
index 2b82d97..b5269ed 100644
--- a/vp9/encoder/x86/vp9_dct_avx2.c
+++ b/vp9/encoder/x86/vp9_dct_avx2.c
@@ -16,7 +16,7 @@
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
- // as the first pass results are transposed, we tranpose the columns (that
+ // as the first pass results are transposed, we transpose the columns (that
// is the transposed rows) and transpose the results (so that it goes back
// in normal/row positions).
int pass;
@@ -46,7 +46,7 @@
in3 = _mm_slli_epi16(in3, 4);
// if (i == 0 && input[0]) input[0] += 1;
{
- // The mask will only contain wether the first value is zero, all
+ // The mask will only contain whether the first value is zero, all
// other comparison will fail as something shifted by 4 (above << 4)
// can never be equal to one. To increment in the non-zero case, we
// add the mask and one for the first element:
@@ -59,7 +59,7 @@
}
// Do the two transform/transpose passes
for (pass = 0; pass < 2; ++pass) {
- // Transform 1/2: Add/substract
+ // Transform 1/2: Add/subtract
const __m128i r0 = _mm_add_epi16(in0, in3);
const __m128i r1 = _mm_add_epi16(in1, in2);
const __m128i r2 = _mm_sub_epi16(in1, in2);
@@ -317,7 +317,7 @@
for (pass = 0; pass < 2; pass++) {
// To store results of each pass before the transpose.
__m128i res0, res1, res2, res3, res4, res5, res6, res7;
- // Add/substract
+ // Add/subtract
const __m128i q0 = _mm_add_epi16(in0, in7);
const __m128i q1 = _mm_add_epi16(in1, in6);
const __m128i q2 = _mm_add_epi16(in2, in5);
@@ -328,7 +328,7 @@
const __m128i q7 = _mm_sub_epi16(in0, in7);
// Work on first four results
{
- // Add/substract
+ // Add/subtract
const __m128i r0 = _mm_add_epi16(q0, q3);
const __m128i r1 = _mm_add_epi16(q1, q2);
const __m128i r2 = _mm_sub_epi16(q1, q2);
@@ -390,7 +390,7 @@
// Combine
const __m128i r0 = _mm_packs_epi32(s0, s1);
const __m128i r1 = _mm_packs_epi32(s2, s3);
- // Add/substract
+ // Add/subtract
const __m128i x0 = _mm_add_epi16(q4, r0);
const __m128i x1 = _mm_sub_epi16(q4, r0);
const __m128i x2 = _mm_sub_epi16(q7, r1);
@@ -1071,7 +1071,7 @@
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
- // as the first pass results are transposed, we tranpose the columns (that
+ // as the first pass results are transposed, we transpose the columns (that
// is the transposed rows) and transpose the results (so that it goes back
// in normal/row positions).
int pass;
@@ -1228,7 +1228,7 @@
}
// Work on the first eight values; fdct8(input, even_results);
{
- // Add/substract
+ // Add/subtract
const __m128i q0 = _mm_add_epi16(input0, input7);
const __m128i q1 = _mm_add_epi16(input1, input6);
const __m128i q2 = _mm_add_epi16(input2, input5);
@@ -1239,7 +1239,7 @@
const __m128i q7 = _mm_sub_epi16(input0, input7);
// Work on first four results
{
- // Add/substract
+ // Add/subtract
const __m128i r0 = _mm_add_epi16(q0, q3);
const __m128i r1 = _mm_add_epi16(q1, q2);
const __m128i r2 = _mm_sub_epi16(q1, q2);
@@ -1303,7 +1303,7 @@
// Combine
const __m128i r0 = _mm_packs_epi32(s0, s1);
const __m128i r1 = _mm_packs_epi32(s2, s3);
- // Add/substract
+ // Add/subtract
const __m128i x0 = _mm_add_epi16(q4, r0);
const __m128i x1 = _mm_sub_epi16(q4, r0);
const __m128i x2 = _mm_sub_epi16(q7, r1);
diff --git a/vp9/encoder/x86/vp9_dct_sse2.c b/vp9/encoder/x86/vp9_dct_sse2.c
index 852cf86..f3735eb 100644
--- a/vp9/encoder/x86/vp9_dct_sse2.c
+++ b/vp9/encoder/x86/vp9_dct_sse2.c
@@ -16,7 +16,7 @@
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
- // as the first pass results are transposed, we tranpose the columns (that
+ // as the first pass results are transposed, we transpose the columns (that
// is the transposed rows) and transpose the results (so that it goes back
// in normal/row positions).
int pass;
@@ -47,7 +47,7 @@
in1 = _mm_slli_epi16(in1, 4);
// if (i == 0 && input[0]) input[0] += 1;
{
- // The mask will only contain wether the first value is zero, all
+ // The mask will only contain whether the first value is zero, all
// other comparison will fail as something shifted by 4 (above << 4)
// can never be equal to one. To increment in the non-zero case, we
// add the mask and one for the first element:
@@ -60,7 +60,7 @@
}
// Do the two transform/transpose passes
for (pass = 0; pass < 2; ++pass) {
- // Transform 1/2: Add/substract
+ // Transform 1/2: Add/subtract
const __m128i r0 = _mm_add_epi16(in0, in1);
const __m128i r1 = _mm_sub_epi16(in0, in1);
const __m128i r2 = _mm_unpacklo_epi64(r0, r1);
@@ -315,7 +315,7 @@
for (pass = 0; pass < 2; pass++) {
// To store results of each pass before the transpose.
__m128i res0, res1, res2, res3, res4, res5, res6, res7;
- // Add/substract
+ // Add/subtract
const __m128i q0 = _mm_add_epi16(in0, in7);
const __m128i q1 = _mm_add_epi16(in1, in6);
const __m128i q2 = _mm_add_epi16(in2, in5);
@@ -326,7 +326,7 @@
const __m128i q7 = _mm_sub_epi16(in0, in7);
// Work on first four results
{
- // Add/substract
+ // Add/subtract
const __m128i r0 = _mm_add_epi16(q0, q3);
const __m128i r1 = _mm_add_epi16(q1, q2);
const __m128i r2 = _mm_sub_epi16(q1, q2);
@@ -388,7 +388,7 @@
// Combine
const __m128i r0 = _mm_packs_epi32(s0, s1);
const __m128i r1 = _mm_packs_epi32(s2, s3);
- // Add/substract
+ // Add/subtract
const __m128i x0 = _mm_add_epi16(q4, r0);
const __m128i x1 = _mm_sub_epi16(q4, r0);
const __m128i x2 = _mm_sub_epi16(q7, r1);
@@ -1069,7 +1069,7 @@
// The 2D transform is done with two passes which are actually pretty
// similar. In the first one, we transform the columns and transpose
// the results. In the second one, we transform the rows. To achieve that,
- // as the first pass results are transposed, we tranpose the columns (that
+ // as the first pass results are transposed, we transpose the columns (that
// is the transposed rows) and transpose the results (so that it goes back
// in normal/row positions).
int pass;
@@ -1226,7 +1226,7 @@
}
// Work on the first eight values; fdct8(input, even_results);
{
- // Add/substract
+ // Add/subtract
const __m128i q0 = _mm_add_epi16(input0, input7);
const __m128i q1 = _mm_add_epi16(input1, input6);
const __m128i q2 = _mm_add_epi16(input2, input5);
@@ -1237,7 +1237,7 @@
const __m128i q7 = _mm_sub_epi16(input0, input7);
// Work on first four results
{
- // Add/substract
+ // Add/subtract
const __m128i r0 = _mm_add_epi16(q0, q3);
const __m128i r1 = _mm_add_epi16(q1, q2);
const __m128i r2 = _mm_sub_epi16(q1, q2);
@@ -1301,7 +1301,7 @@
// Combine
const __m128i r0 = _mm_packs_epi32(s0, s1);
const __m128i r1 = _mm_packs_epi32(s2, s3);
- // Add/substract
+ // Add/subtract
const __m128i x0 = _mm_add_epi16(q4, r0);
const __m128i x1 = _mm_sub_epi16(q4, r0);
const __m128i x2 = _mm_sub_epi16(q7, r1);
diff --git a/vp9/encoder/x86/vp9_subpel_variance_impl_intrin_avx2.c b/vp9/encoder/x86/vp9_subpel_variance_impl_intrin_avx2.c
new file mode 100644
index 0000000..a8f98e9
--- /dev/null
+++ b/vp9/encoder/x86/vp9_subpel_variance_impl_intrin_avx2.c
@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) 2012 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE 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.
+ */
+
+#include <immintrin.h> // AVX2
+#include "vpx_ports/mem.h"
+#include "vp9/encoder/vp9_variance.h"
+
+DECLARE_ALIGNED(32, const unsigned char, vp9_bilinear_filters_avx2[512])= {
+ 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0,
+ 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0,
+ 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1,
+ 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1,
+ 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2,
+ 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2,
+ 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3,
+ 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3,
+ 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4,
+ 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4,
+ 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5,
+ 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5,
+ 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6,
+ 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6,
+ 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7,
+ 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9,
+ 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9,
+ 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10,
+ 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10,
+ 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11,
+ 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11, 5, 11,
+ 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12,
+ 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12,
+ 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13,
+ 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13,
+ 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14,
+ 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14,
+ 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15,
+ 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15};
+
+unsigned int vp9_sub_pixel_variance32xh_avx2(const uint8_t *src,
+ int src_stride,
+ int x_offset,
+ int y_offset,
+ const uint8_t *dst,
+ int dst_stride,
+ int height,
+ unsigned int *sse) {
+ __m256i src_reg, dst_reg, exp_src_lo, exp_src_hi, exp_dst_lo, exp_dst_hi;
+ __m256i sse_reg, sum_reg, sse_reg_hi, res_cmp, sum_reg_lo, sum_reg_hi;
+ __m256i zero_reg;
+ int i, sum;
+ sum_reg = _mm256_set1_epi16(0);
+ sse_reg = _mm256_set1_epi16(0);
+ zero_reg = _mm256_set1_epi16(0);
+
+ if (x_offset == 0) {
+ // x_offset = 0 and y_offset = 0
+ if (y_offset == 0) {
+ for (i = 0; i < height ; i++) {
+ // load source and destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+
+ // expend each byte to 2 bytes
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, zero_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, zero_reg);
+
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ src+= src_stride;
+ dst+= dst_stride;
+ }
+ // x_offset = 0 and y_offset = 8
+ } else if (y_offset == 8) {
+ __m256i src_next_reg;
+ for (i = 0; i < height ; i++) {
+ // load source + next source + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *)
+ (src + src_stride));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+ // average between current and next stride source
+ src_reg = _mm256_avg_epu8(src_reg, src_next_reg);
+
+ // expend each byte to 2 bytes
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, zero_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, zero_reg);
+
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ src+= src_stride;
+ dst+= dst_stride;
+ }
+ // x_offset = 0 and y_offset = bilin interpolation
+ } else {
+ __m256i filter, pw8, src_next_reg;
+#if (ARCH_X86_64)
+ int64_t y_offset64;
+ y_offset64 = y_offset;
+ y_offset64 <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + y_offset64));
+#else
+ y_offset <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + y_offset));
+#endif
+ pw8 = _mm256_set1_epi16(8);
+ for (i = 0; i < height ; i++) {
+ // load current and next source + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *)
+ (src + src_stride));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+
+ // merge current and next source
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, src_next_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, src_next_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, filter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, filter);
+
+ // add 8 to the source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // expand each byte to 2 byte in the destination
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ src+= src_stride;
+ dst+= dst_stride;
+ }
+ }
+ // x_offset = 8 and y_offset = 0
+ } else if (x_offset == 8) {
+ if (y_offset == 0) {
+ __m256i src_next_reg;
+ for (i = 0; i < height ; i++) {
+ // load source and another source starting from the next
+ // following byte + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+
+ // average between source and the next byte following source
+ src_reg = _mm256_avg_epu8(src_reg, src_next_reg);
+
+ // expand each byte to 2 bytes
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, zero_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, zero_reg);
+
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ src+= src_stride;
+ dst+= dst_stride;
+ }
+ // x_offset = 8 and y_offset = 8
+ } else if (y_offset == 8) {
+ __m256i src_next_reg, src_avg;
+ // load source and another source starting from the next
+ // following byte
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+
+ // average between source and the next byte following source
+ src_avg = _mm256_avg_epu8(src_reg, src_next_reg);
+ for (i = 0; i < height ; i++) {
+ src+= src_stride;
+ // load source and another source starting from the next
+ // following byte + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+ // average between source and the next byte following source
+ src_reg = _mm256_avg_epu8(src_reg, src_next_reg);
+
+ // expand each byte to 2 bytes
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // average between previous average to current average
+ src_avg = _mm256_avg_epu8(src_avg, src_reg);
+ // expand each byte to 2 bytes
+ exp_src_lo = _mm256_unpacklo_epi8(src_avg, zero_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_avg, zero_reg);
+
+ // save current source average
+ src_avg = src_reg;
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ dst+= dst_stride;
+ }
+ // x_offset = 8 and y_offset = bilin interpolation
+ } else {
+ __m256i filter, pw8, src_next_reg, src_avg;
+#if (ARCH_X86_64)
+ int64_t y_offset64;
+ y_offset64 = y_offset;
+ y_offset64 <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2+y_offset64));
+#else
+ y_offset <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + y_offset));
+#endif
+ pw8 = _mm256_set1_epi16(8);
+ // load source and another source starting from the next
+ // following byte
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ // average between source and the next byte following source
+ src_avg = _mm256_avg_epu8(src_reg, src_next_reg);
+ for (i = 0; i < height ; i++) {
+ src+= src_stride;
+ // load source and another source starting from the next
+ // following byte + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+ // average between source and the next byte following source
+ src_reg = _mm256_avg_epu8(src_reg, src_next_reg);
+
+ // merge previous average and current average
+ exp_src_lo = _mm256_unpacklo_epi8(src_avg, src_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_avg, src_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, filter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, filter);
+
+ // add 8 to the source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide the source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // expand each byte to 2 bytes
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // save current source average
+ src_avg = src_reg;
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ dst+= dst_stride;
+ }
+ }
+ // x_offset = bilin interpolation and y_offset = 0
+ } else {
+ if (y_offset == 0) {
+ __m256i filter, pw8, src_next_reg;
+#if (ARCH_X86_64)
+ int64_t x_offset64;
+ x_offset64 = x_offset;
+ x_offset64 <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2+x_offset64));
+#else
+ x_offset <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + x_offset));
+#endif
+ pw8 = _mm256_set1_epi16(8);
+ for (i = 0; i < height ; i++) {
+ // load source and another source starting from the next
+ // following byte + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+
+ // merge current and next source
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, src_next_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, src_next_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, filter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, filter);
+
+ // add 8 to source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide the source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // expand each byte to 2 bytes
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ src+= src_stride;
+ dst+= dst_stride;
+ }
+ // x_offset = bilin interpolation and y_offset = 8
+ } else if (y_offset == 8) {
+ __m256i filter, pw8, src_next_reg, src_pack;
+#if (ARCH_X86_64)
+ int64_t x_offset64;
+ x_offset64 = x_offset;
+ x_offset64 <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2+x_offset64));
+#else
+ x_offset <<= 5;
+ filter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + x_offset));
+#endif
+ pw8 = _mm256_set1_epi16(8);
+ // load source and another source starting from the next
+ // following byte
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+
+ // merge current and next stride source
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, src_next_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, src_next_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, filter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, filter);
+
+ // add 8 to source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // convert each 16 bit to 8 bit to each low and high lane source
+ src_pack = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
+ for (i = 0; i < height ; i++) {
+ src+= src_stride;
+
+ // load source and another source starting from the next
+ // following byte + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+
+ // merge current and next stride source
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, src_next_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, src_next_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, filter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, filter);
+
+ // add 8 to source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // convert each 16 bit to 8 bit to each low and high lane source
+ src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
+ // average between previous pack to the current
+ src_pack = _mm256_avg_epu8(src_pack, src_reg);
+
+ // expand each byte to 2 bytes
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ exp_src_lo = _mm256_unpacklo_epi8(src_pack, zero_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_pack, zero_reg);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // calculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ // save previous pack
+ src_pack = src_reg;
+ dst+= dst_stride;
+ }
+ // x_offset = bilin interpolation and y_offset = bilin interpolation
+ } else {
+ __m256i xfilter, yfilter, pw8, src_next_reg, src_pack;
+#if (ARCH_X86_64)
+ int64_t x_offset64, y_offset64;
+ x_offset64 = x_offset;
+ x_offset64 <<= 5;
+ y_offset64 = y_offset;
+ y_offset64 <<= 5;
+ xfilter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2+x_offset64));
+ yfilter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2+y_offset64));
+#else
+ x_offset <<= 5;
+ xfilter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + x_offset));
+ y_offset <<= 5;
+ yfilter = _mm256_load_si256((__m256i const *)
+ (vp9_bilinear_filters_avx2 + y_offset));
+#endif
+ pw8 = _mm256_set1_epi16(8);
+ // load source and another source starting from the next
+ // following byte
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ // merge current and next stride source
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, src_next_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, src_next_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, xfilter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, xfilter);
+
+ // add 8 to the source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide the source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // convert each 16 bit to 8 bit to each low and high lane source
+ src_pack = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
+ for (i = 0; i < height ; i++) {
+ src+= src_stride;
+ // load source and another source starting from the next
+ // following byte + destination
+ src_reg = _mm256_loadu_si256((__m256i const *) (src));
+ src_next_reg = _mm256_loadu_si256((__m256i const *) (src + 1));
+ dst_reg = _mm256_load_si256((__m256i const *) (dst));
+
+ // merge current and next stride source
+ exp_src_lo = _mm256_unpacklo_epi8(src_reg, src_next_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_reg, src_next_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, xfilter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, xfilter);
+
+ // add 8 to source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // convert each 16 bit to 8 bit to each low and high lane source
+ src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
+
+ // merge previous pack to current pack source
+ exp_src_lo = _mm256_unpacklo_epi8(src_pack, src_reg);
+ exp_src_hi = _mm256_unpackhi_epi8(src_pack, src_reg);
+
+ // filter the source
+ exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, yfilter);
+ exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, yfilter);
+
+ // expand each byte to 2 bytes
+ exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg);
+ exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg);
+
+ // add 8 to source
+ exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8);
+ exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8);
+
+ // divide source by 16
+ exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4);
+ exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
+
+ // source - dest
+ exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo);
+ exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi);
+
+ // caculate sum
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo);
+ exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo);
+ sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi);
+ exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi);
+
+ // calculate sse
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo);
+ sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi);
+
+ src_pack = src_reg;
+ dst+= dst_stride;
+ }
+ }
+ }
+ // sum < 0
+ res_cmp = _mm256_cmpgt_epi16(zero_reg, sum_reg);
+ // save the next 8 bytes of each lane of sse
+ sse_reg_hi = _mm256_srli_si256(sse_reg, 8);
+ // merge the result of sum < 0 with sum to add sign to the next 16 bits
+ sum_reg_lo = _mm256_unpacklo_epi16(sum_reg, res_cmp);
+ sum_reg_hi = _mm256_unpackhi_epi16(sum_reg, res_cmp);
+ // add each 8 bytes from every lane of sse and sum
+ sse_reg = _mm256_add_epi32(sse_reg, sse_reg_hi);
+ sum_reg = _mm256_add_epi32(sum_reg_lo, sum_reg_hi);
+
+ // save the next 4 bytes of each lane sse
+ sse_reg_hi = _mm256_srli_si256(sse_reg, 4);
+ // save the next 8 bytes of each lane of sum
+ sum_reg_hi = _mm256_srli_si256(sum_reg, 8);
+
+ // add the first 4 bytes to the next 4 bytes sse
+ sse_reg = _mm256_add_epi32(sse_reg, sse_reg_hi);
+ // add the first 8 bytes to the next 8 bytes
+ sum_reg = _mm256_add_epi32(sum_reg, sum_reg_hi);
+ // extract the low lane and the high lane and add the results
+ *((int*)sse)= _mm_cvtsi128_si32(_mm256_castsi256_si128(sse_reg)) +
+ _mm_cvtsi128_si32(_mm256_extractf128_si256(sse_reg, 1));
+ sum_reg_hi = _mm256_srli_si256(sum_reg, 4);
+ sum_reg = _mm256_add_epi32(sum_reg, sum_reg_hi);
+ sum = _mm_cvtsi128_si32(_mm256_castsi256_si128(sum_reg)) +
+ _mm_cvtsi128_si32(_mm256_extractf128_si256(sum_reg, 1));
+ return sum;
+}
diff --git a/vp9/encoder/x86/vp9_variance_avx2.c b/vp9/encoder/x86/vp9_variance_avx2.c
index c9b90d5..02007a3 100644
--- a/vp9/encoder/x86/vp9_variance_avx2.c
+++ b/vp9/encoder/x86/vp9_variance_avx2.c
@@ -42,6 +42,18 @@
int *Sum
);
+unsigned int vp9_sub_pixel_variance32xh_avx2
+(
+ const uint8_t *src,
+ int src_stride,
+ int x_offset,
+ int y_offset,
+ const uint8_t *dst,
+ int dst_stride,
+ int height,
+ unsigned int *sse
+);
+
static void variance_avx2(const unsigned char *src_ptr, int source_stride,
const unsigned char *ref_ptr, int recon_stride,
int w, int h, unsigned int *sse, int *sum,
@@ -155,3 +167,43 @@
*sse = var;
return (var - (((int64_t)avg * avg) >> 11));
}
+
+unsigned int vp9_sub_pixel_variance64x64_avx2(const uint8_t *src,
+ int src_stride,
+ int x_offset,
+ int y_offset,
+ const uint8_t *dst,
+ int dst_stride,
+ unsigned int *sse_ptr) {
+ // processing 32 elements in parallel
+ unsigned int sse;
+ int se = vp9_sub_pixel_variance32xh_avx2(src, src_stride, x_offset,
+ y_offset, dst, dst_stride,
+ 64, &sse);
+ // processing the next 32 elements in parallel
+ unsigned int sse2;
+ int se2 = vp9_sub_pixel_variance32xh_avx2(src + 32, src_stride,
+ x_offset, y_offset,
+ dst + 32, dst_stride,
+ 64, &sse2);
+ se += se2;
+ sse += sse2;
+ *sse_ptr = sse;
+ return sse - (((int64_t)se * se) >> 12);
+}
+
+unsigned int vp9_sub_pixel_variance32x32_avx2(const uint8_t *src,
+ int src_stride,
+ int x_offset,
+ int y_offset,
+ const uint8_t *dst,
+ int dst_stride,
+ unsigned int *sse_ptr) {
+ // processing 32 element in parallel
+ unsigned int sse;
+ int se = vp9_sub_pixel_variance32xh_avx2(src, src_stride, x_offset,
+ y_offset, dst, dst_stride,
+ 32, &sse);
+ *sse_ptr = sse;
+ return sse - (((int64_t)se * se) >> 10);
+}
diff --git a/vp9/vp9_common.mk b/vp9/vp9_common.mk
index 48d6a7c..a448b3c 100644
--- a/vp9/vp9_common.mk
+++ b/vp9/vp9_common.mk
@@ -80,6 +80,7 @@
VP9_COMMON_SRCS-$(HAVE_SSSE3) += common/x86/vp9_subpixel_8t_ssse3.asm
VP9_COMMON_SRCS-$(HAVE_SSSE3) += common/x86/vp9_subpixel_bilinear_ssse3.asm
VP9_COMMON_SRCS-$(HAVE_AVX2) += common/x86/vp9_subpixel_8t_intrin_avx2.c
+VP9_COMMON_SRCS-$(HAVE_SSSE3) += common/x86/vp9_subpixel_8t_intrin_ssse3.c
ifeq ($(CONFIG_VP9_POSTPROC),yes)
VP9_COMMON_SRCS-$(HAVE_MMX) += common/x86/vp9_postproc_mmx.asm
VP9_COMMON_SRCS-$(HAVE_SSE2) += common/x86/vp9_postproc_sse2.asm
diff --git a/vp9/vp9_cx_iface.c b/vp9/vp9_cx_iface.c
index 8072f78..fbdad74 100644
--- a/vp9/vp9_cx_iface.c
+++ b/vp9/vp9_cx_iface.c
@@ -365,7 +365,7 @@
memcpy(oxcf->ts_rate_decimator, cfg.ts_rate_decimator,
sizeof(cfg.ts_rate_decimator));
} else if (oxcf->ts_number_layers == 1) {
- oxcf->ts_target_bitrate[0] = oxcf->target_bandwidth;
+ oxcf->ts_target_bitrate[0] = (int)oxcf->target_bandwidth;
oxcf->ts_rate_decimator[0] = 1;
}
@@ -639,7 +639,7 @@
*x++ = marker;
for (i = 0; i < ctx->pending_frame_count; i++) {
- int this_sz = ctx->pending_frame_sizes[i];
+ unsigned int this_sz = (unsigned int)ctx->pending_frame_sizes[i];
for (j = 0; j <= mag; j++) {
*x++ = this_sz & 0xff;
@@ -1049,7 +1049,7 @@
return VPX_CODEC_INVALID_PARAM;
}
if (cpi->svc.spatial_layer_id < 0 ||
- cpi->svc.spatial_layer_id >= ctx->cfg.ss_number_layers) {
+ cpi->svc.spatial_layer_id >= (int)ctx->cfg.ss_number_layers) {
return VPX_CODEC_INVALID_PARAM;
}
return VPX_CODEC_OK;
diff --git a/vp9/vp9_dx_iface.c b/vp9/vp9_dx_iface.c
index 1941fc0..76cbebf 100644
--- a/vp9/vp9_dx_iface.c
+++ b/vp9/vp9_dx_iface.c
@@ -214,7 +214,7 @@
? sizeof(vp9_stream_info_t)
: sizeof(vpx_codec_stream_info_t);
memcpy(si, &ctx->si, sz);
- si->sz = sz;
+ si->sz = (unsigned int)sz;
return VPX_CODEC_OK;
}
@@ -462,7 +462,7 @@
while (data_start < data_end && *data_start == 0)
data_start++;
- data_sz = data_end - data_start;
+ data_sz = (unsigned int)(data_end - data_start);
} while (data_start < data_end);
return res;
}
diff --git a/vp9/vp9cx.mk b/vp9/vp9cx.mk
index c0d973b..27dd6f6 100644
--- a/vp9/vp9cx.mk
+++ b/vp9/vp9cx.mk
@@ -86,6 +86,7 @@
VP9_CX_SRCS-$(HAVE_AVX2) += encoder/x86/vp9_variance_impl_intrin_avx2.c
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_sad4d_sse2.asm
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_subpel_variance_impl_sse2.asm
+VP9_CX_SRCS-$(HAVE_AVX2) += encoder/x86/vp9_subpel_variance_impl_intrin_avx2.c
VP9_CX_SRCS-$(HAVE_SSE2) += encoder/x86/vp9_temporal_filter_apply_sse2.asm
VP9_CX_SRCS-$(HAVE_SSE3) += encoder/x86/vp9_sad_sse3.asm
diff --git a/vpx/vp8cx.h b/vpx/vp8cx.h
index d0ac1af..f7dde62 100644
--- a/vpx/vp8cx.h
+++ b/vpx/vp8cx.h
@@ -297,9 +297,16 @@
int alt_fb_idx; /**< alt reference frame frame buffer index */
} vpx_svc_parameters_t;
+/*!\brief vp9 svc layer parameters
+ *
+ * This defines the spatial and temporal layer id numbers for svc encoding.
+ * This is used with the #VP9E_SET_SVC_LAYER_ID control to set the spatial and
+ * temporal layer id for the current frame.
+ *
+ */
typedef struct vpx_svc_layer_id {
- int spatial_layer_id;
- int temporal_layer_id;
+ int spatial_layer_id; /**< Spatial layer id number. */
+ int temporal_layer_id; /**< Temporal layer id number. */
} vpx_svc_layer_id_t;
/*!\brief VP8 encoder control function parameter type
diff --git a/vpx_scale/yv12config.h b/vpx_scale/yv12config.h
index 525f3a0..cdde75c 100644
--- a/vpx_scale/yv12config.h
+++ b/vpx_scale/yv12config.h
@@ -24,62 +24,60 @@
#define VP9_ENC_BORDER_IN_PIXELS 160
#define VP9_DEC_BORDER_IN_PIXELS 32
- typedef struct yv12_buffer_config {
- int y_width;
- int y_height;
- int y_crop_width;
- int y_crop_height;
- int y_stride;
- /* int yinternal_width; */
+typedef struct yv12_buffer_config {
+ int y_width;
+ int y_height;
+ int y_crop_width;
+ int y_crop_height;
+ int y_stride;
- int uv_width;
- int uv_height;
- int uv_crop_width;
- int uv_crop_height;
- int uv_stride;
- /* int uvinternal_width; */
+ int uv_width;
+ int uv_height;
+ int uv_crop_width;
+ int uv_crop_height;
+ int uv_stride;
- int alpha_width;
- int alpha_height;
- int alpha_stride;
+ int alpha_width;
+ int alpha_height;
+ int alpha_stride;
- uint8_t *y_buffer;
- uint8_t *u_buffer;
- uint8_t *v_buffer;
- uint8_t *alpha_buffer;
+ uint8_t *y_buffer;
+ uint8_t *u_buffer;
+ uint8_t *v_buffer;
+ uint8_t *alpha_buffer;
- uint8_t *buffer_alloc;
- int buffer_alloc_sz;
- int border;
- int frame_size;
+ uint8_t *buffer_alloc;
+ int buffer_alloc_sz;
+ int border;
+ int frame_size;
- int corrupted;
- int flags;
- } YV12_BUFFER_CONFIG;
+ int corrupted;
+ int flags;
+} YV12_BUFFER_CONFIG;
- int vp8_yv12_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
+int vp8_yv12_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
+ int width, int height, int border);
+int vp8_yv12_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
int width, int height, int border);
- int vp8_yv12_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
- int width, int height, int border);
- int vp8_yv12_de_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf);
+int vp8_yv12_de_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf);
- int vp9_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
+int vp9_alloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
+ int width, int height, int ss_x, int ss_y,
+ int border);
+
+// Updates the yv12 buffer config with the frame buffer. If cb is not
+// NULL, then libvpx is using the frame buffer callbacks to handle memory.
+// If cb is not NULL, libvpx will call cb with minimum size in bytes needed
+// to decode the current frame. If cb is NULL, libvpx will allocate memory
+// internally to decode the current frame. Returns 0 on success. Returns < 0
+// on failure.
+int vp9_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
int width, int height, int ss_x, int ss_y,
- int border);
-
- // Updates the yv12 buffer config with the frame buffer. If cb is not
- // NULL, then libvpx is using the frame buffer callbacks to handle memory.
- // If cb is not NULL, libvpx will call cb with minimum size in bytes needed
- // to decode the current frame. If cb is NULL, libvpx will allocate memory
- // internally to decode the current frame. Returns 0 on success. Returns < 0
- // on failure.
- int vp9_realloc_frame_buffer(YV12_BUFFER_CONFIG *ybf,
- int width, int height, int ss_x, int ss_y,
- int border,
- vpx_codec_frame_buffer_t *fb,
- vpx_get_frame_buffer_cb_fn_t cb,
- void *cb_priv);
- int vp9_free_frame_buffer(YV12_BUFFER_CONFIG *ybf);
+ int border,
+ vpx_codec_frame_buffer_t *fb,
+ vpx_get_frame_buffer_cb_fn_t cb,
+ void *cb_priv);
+int vp9_free_frame_buffer(YV12_BUFFER_CONFIG *ybf);
#ifdef __cplusplus
}
diff --git a/vpxdec.c b/vpxdec.c
index d8157d0..660f613 100644
--- a/vpxdec.c
+++ b/vpxdec.c
@@ -791,7 +791,8 @@
vpx_usec_timer_start(&timer);
- if (vpx_codec_decode(&decoder, buf, bytes_in_buffer, NULL, 0)) {
+ if (vpx_codec_decode(&decoder, buf, (unsigned int)bytes_in_buffer,
+ NULL, 0)) {
const char *detail = vpx_codec_error_detail(&decoder);
warn("Failed to decode frame %d: %s",
frame_in, vpx_codec_error(&decoder));
@@ -873,7 +874,7 @@
vpx_input_ctx.height,
&vpx_input_ctx.framerate, img->fmt);
if (do_md5) {
- MD5Update(&md5_ctx, (md5byte *)buf, len);
+ MD5Update(&md5_ctx, (md5byte *)buf, (unsigned int)len);
} else {
fputs(buf, outfile);
}
@@ -882,7 +883,7 @@
// Y4M frame header
len = y4m_write_frame_header(buf, sizeof(buf));
if (do_md5) {
- MD5Update(&md5_ctx, (md5byte *)buf, len);
+ MD5Update(&md5_ctx, (md5byte *)buf, (unsigned int)len);
} else {
fputs(buf, outfile);
}
diff --git a/vpxenc.c b/vpxenc.c
index 73b3144..02856d9 100644
--- a/vpxenc.c
+++ b/vpxenc.c
@@ -717,17 +717,6 @@
argj++;
}
- /* Validate global config */
- if (global->passes == 0) {
-#if CONFIG_VP9_ENCODER
- // Make default VP9 passes = 2 until there is a better quality 1-pass
- // encoder
- global->passes = strcmp(global->codec->name, "vp9") == 0 ? 2 : 1;
-#else
- global->passes = 1;
-#endif
- }
-
if (global->pass) {
/* DWIM: Assume the user meant passes=2 if pass=2 is specified */
if (global->pass > global->passes) {
@@ -736,6 +725,23 @@
global->passes = global->pass;
}
}
+ /* Validate global config */
+ if (global->passes == 0) {
+#if CONFIG_VP9_ENCODER
+ // Make default VP9 passes = 2 until there is a better quality 1-pass
+ // encoder
+ global->passes = (strcmp(global->codec->name, "vp9") == 0 &&
+ global->deadline != VPX_DL_REALTIME) ? 2 : 1;
+#else
+ global->passes = 1;
+#endif
+ }
+
+ if (global->deadline == VPX_DL_REALTIME &&
+ global->passes > 1) {
+ warn("Enforcing one-pass encoding in realtime mode\n");
+ global->passes = 1;
+ }
}
@@ -826,6 +832,10 @@
/* Allows removal of the application version from the EBML tags */
stream->ebml.debug = global->debug;
+
+ /* Default lag_in_frames is 0 in realtime mode */
+ if (global->deadline == VPX_DL_REALTIME)
+ stream->config.cfg.g_lag_in_frames = 0;
}
/* Output files must be specified for each stream */
@@ -874,59 +884,63 @@
continue;
}
- if (0);
- else if (arg_match(&arg, &outputfile, argi))
+ if (0) {
+ } else if (arg_match(&arg, &outputfile, argi)) {
config->out_fn = arg.val;
- else if (arg_match(&arg, &fpf_name, argi))
+ } else if (arg_match(&arg, &fpf_name, argi)) {
config->stats_fn = arg.val;
- else if (arg_match(&arg, &use_ivf, argi))
+ } else if (arg_match(&arg, &use_ivf, argi)) {
config->write_webm = 0;
- else if (arg_match(&arg, &threads, argi))
+ } else if (arg_match(&arg, &threads, argi)) {
config->cfg.g_threads = arg_parse_uint(&arg);
- else if (arg_match(&arg, &profile, argi))
+ } else if (arg_match(&arg, &profile, argi)) {
config->cfg.g_profile = arg_parse_uint(&arg);
- else if (arg_match(&arg, &width, argi))
+ } else if (arg_match(&arg, &width, argi)) {
config->cfg.g_w = arg_parse_uint(&arg);
- else if (arg_match(&arg, &height, argi))
+ } else if (arg_match(&arg, &height, argi)) {
config->cfg.g_h = arg_parse_uint(&arg);
- else if (arg_match(&arg, &stereo_mode, argi))
+ } else if (arg_match(&arg, &stereo_mode, argi)) {
config->stereo_fmt = arg_parse_enum_or_int(&arg);
- else if (arg_match(&arg, &timebase, argi)) {
+ } else if (arg_match(&arg, &timebase, argi)) {
config->cfg.g_timebase = arg_parse_rational(&arg);
validate_positive_rational(arg.name, &config->cfg.g_timebase);
- } else if (arg_match(&arg, &error_resilient, argi))
+ } else if (arg_match(&arg, &error_resilient, argi)) {
config->cfg.g_error_resilient = arg_parse_uint(&arg);
- else if (arg_match(&arg, &lag_in_frames, argi))
+ } else if (arg_match(&arg, &lag_in_frames, argi)) {
config->cfg.g_lag_in_frames = arg_parse_uint(&arg);
- else if (arg_match(&arg, &dropframe_thresh, argi))
+ if (global->deadline == VPX_DL_REALTIME &&
+ config->cfg.g_lag_in_frames != 0) {
+ warn("non-zero %s option ignored in realtime mode.\n", arg.name);
+ config->cfg.g_lag_in_frames = 0;
+ }
+ } else if (arg_match(&arg, &dropframe_thresh, argi)) {
config->cfg.rc_dropframe_thresh = arg_parse_uint(&arg);
- else if (arg_match(&arg, &resize_allowed, argi))
+ } else if (arg_match(&arg, &resize_allowed, argi)) {
config->cfg.rc_resize_allowed = arg_parse_uint(&arg);
- else if (arg_match(&arg, &resize_up_thresh, argi))
+ } else if (arg_match(&arg, &resize_up_thresh, argi)) {
config->cfg.rc_resize_up_thresh = arg_parse_uint(&arg);
- else if (arg_match(&arg, &resize_down_thresh, argi))
+ } else if (arg_match(&arg, &resize_down_thresh, argi)) {
config->cfg.rc_resize_down_thresh = arg_parse_uint(&arg);
- else if (arg_match(&arg, &end_usage, argi))
+ } else if (arg_match(&arg, &end_usage, argi)) {
config->cfg.rc_end_usage = arg_parse_enum_or_int(&arg);
- else if (arg_match(&arg, &target_bitrate, argi))
+ } else if (arg_match(&arg, &target_bitrate, argi)) {
config->cfg.rc_target_bitrate = arg_parse_uint(&arg);
- else if (arg_match(&arg, &min_quantizer, argi))
+ } else if (arg_match(&arg, &min_quantizer, argi)) {
config->cfg.rc_min_quantizer = arg_parse_uint(&arg);
- else if (arg_match(&arg, &max_quantizer, argi))
+ } else if (arg_match(&arg, &max_quantizer, argi)) {
config->cfg.rc_max_quantizer = arg_parse_uint(&arg);
- else if (arg_match(&arg, &undershoot_pct, argi))
+ } else if (arg_match(&arg, &undershoot_pct, argi)) {
config->cfg.rc_undershoot_pct = arg_parse_uint(&arg);
- else if (arg_match(&arg, &overshoot_pct, argi))
+ } else if (arg_match(&arg, &overshoot_pct, argi)) {
config->cfg.rc_overshoot_pct = arg_parse_uint(&arg);
- else if (arg_match(&arg, &buf_sz, argi))
+ } else if (arg_match(&arg, &buf_sz, argi)) {
config->cfg.rc_buf_sz = arg_parse_uint(&arg);
- else if (arg_match(&arg, &buf_initial_sz, argi))
+ } else if (arg_match(&arg, &buf_initial_sz, argi)) {
config->cfg.rc_buf_initial_sz = arg_parse_uint(&arg);
- else if (arg_match(&arg, &buf_optimal_sz, argi))
+ } else if (arg_match(&arg, &buf_optimal_sz, argi)) {
config->cfg.rc_buf_optimal_sz = arg_parse_uint(&arg);
- else if (arg_match(&arg, &bias_pct, argi)) {
- config->cfg.rc_2pass_vbr_bias_pct = arg_parse_uint(&arg);
-
+ } else if (arg_match(&arg, &bias_pct, argi)) {
+ config->cfg.rc_2pass_vbr_bias_pct = arg_parse_uint(&arg);
if (global->passes < 2)
warn("option %s ignored in one-pass mode.\n", arg.name);
} else if (arg_match(&arg, &minsection_pct, argi)) {
@@ -939,16 +953,15 @@
if (global->passes < 2)
warn("option %s ignored in one-pass mode.\n", arg.name);
- } else if (arg_match(&arg, &kf_min_dist, argi))
+ } else if (arg_match(&arg, &kf_min_dist, argi)) {
config->cfg.kf_min_dist = arg_parse_uint(&arg);
- else if (arg_match(&arg, &kf_max_dist, argi)) {
+ } else if (arg_match(&arg, &kf_max_dist, argi)) {
config->cfg.kf_max_dist = arg_parse_uint(&arg);
config->have_kf_max_dist = 1;
- } else if (arg_match(&arg, &kf_disabled, argi))
+ } else if (arg_match(&arg, &kf_disabled, argi)) {
config->cfg.kf_mode = VPX_KF_DISABLED;
- else {
+ } else {
int i, match = 0;
-
for (i = 0; ctrl_args[i]; i++) {
if (arg_match(&arg, ctrl_args[i], argi)) {
int j;
@@ -972,12 +985,10 @@
}
}
-
if (!match)
argj++;
}
}
-
return eos_mark_found;
}
