generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote branch 'internal/upstream' into HEAD

Browse Source
This commit is contained in:
John Koleszar 2010-09-28 00:05:05 -04:00
commit 6804199073
12 changed files with 106 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build/make/configure.sh
View File

@ -567,13 +567,13 @@ process_common_toolchain() {
# Handle darwin variants
case ${toolchain} in
*-darwin8-gcc)
*-darwin8-*)
add_cflags "-isysroot /Developer/SDKs/MacOSX10.4u.sdk"
add_cflags "-mmacosx-version-min=10.4"
add_ldflags "-isysroot /Developer/SDKs/MacOSX10.4u.sdk"
add_ldflags "-mmacosx-version-min=10.4"
;;
*-darwin9-gcc)
*-darwin9-*)
add_cflags "-isysroot /Developer/SDKs/MacOSX10.5.sdk"
add_cflags "-mmacosx-version-min=10.5"
add_ldflags "-isysroot /Developer/SDKs/MacOSX10.5.sdk"

37
vp8/common/arm/armv6/sixtappredict8x4_v6.asm
View File

@ -25,10 +25,10 @@
;and the result is stored in transpose.
|vp8_sixtap_predict8x4_armv6| PROC
stmdb sp!, {r4 - r11, lr}
sub sp, sp, #184 ;reserve space on stack for temporary storage: 20x(8+1) +4
str r3, [sp, #-184]! ;reserve space on stack for temporary storage, store yoffset
cmp r2, #0 ;skip first_pass filter if xoffset=0
str r3, [sp], #4 ;store yoffset
add lr, sp, #4 ;point to temporary buffer
beq skip_firstpass_filter
;first-pass filter
@ -45,7 +45,6 @@
mov r2, #0x90000 ; height=9 is top part of counter
sub r1, r1, #8
mov lr, #20
|first_pass_hloop_v6|
ldrb r6, [r0, #-5] ; load source data
@ -83,10 +82,10 @@
tst r2, #0xff ; test loop counter
usat r11, #8, r11, asr #7
add r12, r12, #0x40
strh r11, [sp], lr ; result is transposed and stored, which
strh r11, [lr], #20 ; result is transposed and stored, which
usat r12, #8, r12, asr #7
strh r12, [sp], lr
strh r12, [lr], #20
movne r11, r6
movne r12, r7
@ -107,8 +106,7 @@
subs r2, r2, #0x10000
mov r6, #158
sub sp, sp, r6
sub lr, lr, #158
add r0, r0, r1 ; move to next input line
@ -116,10 +114,7 @@
;second pass filter
secondpass_filter
mov r1, #18
sub sp, sp, r1 ; 18+4
ldr r3, [sp, #-4] ; load back yoffset
ldr r3, [sp], #4 ; load back yoffset
ldr r0, [sp, #216] ; load dst address from stack 180+36
ldr r1, [sp, #220] ; load dst stride from stack 180+40
@ -192,30 +187,28 @@ skip_firstpass_filter
sub r0, r0, r1, lsl #1
sub r1, r1, #8
mov r2, #9
mov r3, #20
skip_firstpass_hloop
ldrb r4, [r0], #1 ; load data
subs r2, r2, #1
ldrb r5, [r0], #1
strh r4, [sp], r3 ; store it to immediate buffer
strh r4, [lr], #20 ; store it to immediate buffer
ldrb r6, [r0], #1 ; load data
strh r5, [sp], r3
strh r5, [lr], #20
ldrb r7, [r0], #1
strh r6, [sp], r3
strh r6, [lr], #20
ldrb r8, [r0], #1
strh r7, [sp], r3
strh r7, [lr], #20
ldrb r9, [r0], #1
strh r8, [sp], r3
strh r8, [lr], #20
ldrb r10, [r0], #1
strh r9, [sp], r3
strh r9, [lr], #20
ldrb r11, [r0], #1
strh r10, [sp], r3
strh r10, [lr], #20
add r0, r0, r1 ; move to next input line
strh r11, [sp], r3
strh r11, [lr], #20
mov r4, #158
sub sp, sp, r4 ; move over to next column
sub lr, lr, #158 ; move over to next column
bne skip_firstpass_hloop
b secondpass_filter

46
vp8/common/arm/neon/loopfilterhorizontaledge_uv_neon.asm
View File

@ -55,8 +55,7 @@
vld1.s8 {d4[], d5[]}, [r12] ; thresh
ldr r12, _lfhuv_coeff_
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
vabd.u8 q13, q5, q6 ; abs(p1 - p0)
@ -65,22 +64,19 @@
vabd.u8 q4, q10, q9 ; abs(q3 - q2)
vabd.u8 q9, q6, q7 ; abs(p0 - q0)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q4
vmax.u8 q15, q11, q12
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q4, q1, q4 ; (abs(q3 - q2) > limit)*-1
vadd.u8 q0, q0, q0 ; flimit * 2
vadd.u8 q0, q0, q1 ; flimit * 2 + limit
vand q15, q15, q12
vand q10, q10, q11
vand q3, q3, q4
vcge.u8 q15, q1, q15 ; (max > limit) * -1
vabd.u8 q2, q5, q8 ; abs(p1 - q1)
vqadd.u8 q9, q9, q9 ; abs(p0 - q0) * 2
@ -90,8 +86,6 @@
vld1.u8 {q0}, [r12]!
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -100,26 +94,20 @@
;;;;;;;;;;;;;;
vld1.u8 {q10}, [r12]!
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q11, d15, d13
vand q3, q3, q9
vmovl.u8 q4, d20
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
vorr q14, q13, q14 ; q14: vp8_hevmask
;vmul.i8 q2, q2, q10 ; 3 * ( qs0 - ps0)
vmul.i16 q2, q2, q4 ; 3 * ( qs0 - ps0)
vmul.i16 q11, q11, q4
vand q1, q1, q14 ; vp8_filter &= hev
vand q15, q15, q3 ; q15: vp8_filter_mask
;;
;vld1.u8 {q4}, [r12]! ;no need 7 any more
vand q15, q15, q9 ; vp8_filter_mask
;vqadd.s8 q1, q1, q2
vaddw.s8 q2, q2, d2
vaddw.s8 q11, q11, d3
@ -130,21 +118,6 @@
;;
vand q1, q1, q15 ; vp8_filter &= mask
;;
;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q1, q4 ; s = vp8_filter & 7
; vqadd.s8 q1, q1, q9 ; vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
;;;;
; vshr.s8 q1, q1, #3 ; vp8_filter >>= 3
; vceq.i8 q2, q2, q9 ; s = (s==4)*-1
;;
; ;calculate output
; vqsub.s8 q10, q7, q1 ; u = vp8_signed_char_clamp(qs0 - vp8_filter)
; vqadd.s8 q11, q2, q1 ; u = vp8_signed_char_clamp(s + vp8_filter)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; q10=3
vqadd.s8 q2, q1, q10 ; Filter2 = vp8_signed_char_clamp(vp8_filter+3)
vqadd.s8 q1, q1, q9 ; Filter1 = vp8_signed_char_clamp(vp8_filter+4)
vshr.s8 q2, q2, #3 ; Filter2 >>= 3
@ -168,7 +141,6 @@
;;
vqadd.s8 q13, q5, q1 ; u = vp8_signed_char_clamp(ps1 + vp8_filter)
;vqadd.s8 q11, q6, q11 ; u = vp8_signed_char_clamp(ps0 + u)
vqsub.s8 q12, q8, q1 ; u = vp8_signed_char_clamp(qs1 - vp8_filter)
;

46
vp8/common/arm/neon/loopfilterhorizontaledge_y_neon.asm
View File

@ -39,8 +39,7 @@
ldr r12, _lfhy_coeff_
vld1.u8 {q7}, [r0], r1 ; q0
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vld1.u8 {q8}, [r0], r1 ; q1
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
@ -52,22 +51,19 @@
vabd.u8 q4, q10, q9 ; abs(q3 - q2)
vabd.u8 q9, q6, q7 ; abs(p0 - q0)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q4
vmax.u8 q15, q11, q12
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q4, q1, q4 ; (abs(q3 - q2) > limit)*-1
vadd.u8 q0, q0, q0 ; flimit * 2
vadd.u8 q0, q0, q1 ; flimit * 2 + limit
vand q15, q15, q12
vand q10, q10, q11
vand q3, q3, q4
vcge.u8 q15, q1, q15
vabd.u8 q2, q5, q8 ; abs(p1 - q1)
vqadd.u8 q9, q9, q9 ; abs(p0 - q0) * 2
@ -77,8 +73,6 @@
vld1.u8 {q0}, [r12]!
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -87,26 +81,20 @@
;;;;;;;;;;;;;;
vld1.u8 {q10}, [r12]!
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q11, d15, d13
vand q3, q3, q9
vmovl.u8 q4, d20
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
vorr q14, q13, q14 ; q14: vp8_hevmask
;vmul.i8 q2, q2, q10 ; 3 * ( qs0 - ps0)
vmul.i16 q2, q2, q4 ; 3 * ( qs0 - ps0)
vmul.i16 q11, q11, q4
vand q1, q1, q14 ; vp8_filter &= hev
vand q15, q15, q3 ; q15: vp8_filter_mask
;;
;vld1.u8 {q4}, [r12]! ;no need 7 any more
vand q15, q15, q9 ; vp8_filter_mask
;vqadd.s8 q1, q1, q2
vaddw.s8 q2, q2, d2
vaddw.s8 q11, q11, d3
@ -117,21 +105,6 @@
;;
vand q1, q1, q15 ; vp8_filter &= mask
;;
;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q1, q4 ; s = vp8_filter & 7
; vqadd.s8 q1, q1, q9 ; vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
;;;;
; vshr.s8 q1, q1, #3 ; vp8_filter >>= 3
; vceq.i8 q2, q2, q9 ; s = (s==4)*-1
;;
; ;calculate output
; vqsub.s8 q10, q7, q1 ; u = vp8_signed_char_clamp(qs0 - vp8_filter)
; vqadd.s8 q11, q2, q1 ; u = vp8_signed_char_clamp(s + vp8_filter)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; q10=3
vqadd.s8 q2, q1, q10 ; Filter2 = vp8_signed_char_clamp(vp8_filter+3)
vqadd.s8 q1, q1, q9 ; Filter1 = vp8_signed_char_clamp(vp8_filter+4)
vshr.s8 q2, q2, #3 ; Filter2 >>= 3
@ -153,7 +126,6 @@
add r2, r1, r0
vqadd.s8 q13, q5, q1 ; u = vp8_signed_char_clamp(ps1 + vp8_filter)
;vqadd.s8 q11, q6, q11 ; u = vp8_signed_char_clamp(ps0 + u)
vqsub.s8 q12, q8, q1 ; u = vp8_signed_char_clamp(qs1 - vp8_filter)
add r3, r2, r1

47
vp8/common/arm/neon/loopfilterverticaledge_uv_neon.asm
View File

@ -71,8 +71,7 @@
vld1.s8 {d4[], d5[]}, [r12] ; thresh
ldr r12, _vlfuv_coeff_
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
vabd.u8 q13, q5, q6 ; abs(p1 - p0)
@ -81,22 +80,19 @@
vabd.u8 q4, q10, q9 ; abs(q3 - q2)
vabd.u8 q9, q6, q7 ; abs(p0 - q0)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q4
vmax.u8 q15, q11, q12
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q4, q1, q4 ; (abs(q3 - q2) > limit)*-1
vadd.u8 q0, q0, q0 ; flimit * 2
vadd.u8 q0, q0, q1 ; flimit * 2 + limit
vand q15, q15, q12
vand q10, q10, q11
vand q3, q3, q4
vcge.u8 q15, q1, q15
vabd.u8 q2, q5, q8 ; abs(p1 - q1)
vqadd.u8 q9, q9, q9 ; abs(p0 - q0) * 2
@ -106,9 +102,6 @@
vld1.u8 {q0}, [r12]!
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -117,26 +110,20 @@
;;;;;;;;;;;;;;
vld1.u8 {q10}, [r12]!
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q11, d15, d13
vand q3, q3, q9
vmovl.u8 q4, d20
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
vorr q14, q13, q14 ; q14: vp8_hevmask
;vmul.i8 q2, q2, q10 ; 3 * ( qs0 - ps0)
vmul.i16 q2, q2, q4 ; 3 * ( qs0 - ps0)
vmul.i16 q11, q11, q4
vand q1, q1, q14 ; vp8_filter &= hev
vand q15, q15, q3 ; q15: vp8_filter_mask
;;
;vld1.u8 {q4}, [r12]! ;no need 7 any more
vand q15, q15, q9 ; vp8_filter_mask
;vqadd.s8 q1, q1, q2
vaddw.s8 q2, q2, d2
vaddw.s8 q11, q11, d3
@ -147,21 +134,6 @@
;;
vand q1, q1, q15 ; vp8_filter &= mask
;;
;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q1, q4 ; s = vp8_filter & 7
; vqadd.s8 q1, q1, q9 ; vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
;;;;
; vshr.s8 q1, q1, #3 ; vp8_filter >>= 3
; vceq.i8 q2, q2, q9 ; s = (s==4)*-1
;;
; ;calculate output
; vqsub.s8 q10, q7, q1 ; u = vp8_signed_char_clamp(qs0 - vp8_filter)
; vqadd.s8 q11, q2, q1 ; u = vp8_signed_char_clamp(s + vp8_filter)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; q10=3
vqadd.s8 q2, q1, q10 ; Filter2 = vp8_signed_char_clamp(vp8_filter+3)
vqadd.s8 q1, q1, q9 ; Filter1 = vp8_signed_char_clamp(vp8_filter+4)
vshr.s8 q2, q2, #3 ; Filter2 >>= 3
@ -182,7 +154,6 @@
add r2, r2, #2
vqadd.s8 q13, q5, q1 ; u = vp8_signed_char_clamp(ps1 + vp8_filter)
;vqadd.s8 q11, q6, q11 ; u = vp8_signed_char_clamp(ps0 + u)
vqsub.s8 q12, q8, q1 ; u = vp8_signed_char_clamp(qs1 - vp8_filter)
veor q7, q10, q0 ; *oq0 = u^0x80

47
vp8/common/arm/neon/loopfilterverticaledge_y_neon.asm
View File

@ -67,8 +67,7 @@
vtrn.8 q7, q8
vtrn.8 q9, q10
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
vabd.u8 q13, q5, q6 ; abs(p1 - p0)
@ -77,22 +76,19 @@
vabd.u8 q4, q10, q9 ; abs(q3 - q2)
vabd.u8 q9, q6, q7 ; abs(p0 - q0)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q4
vmax.u8 q15, q11, q12
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q4, q1, q4 ; (abs(q3 - q2) > limit)*-1
vadd.u8 q0, q0, q0 ; flimit * 2
vadd.u8 q0, q0, q1 ; flimit * 2 + limit
vand q15, q15, q12
vand q10, q10, q11
vand q3, q3, q4
vcge.u8 q15, q1, q15
vabd.u8 q2, q5, q8 ; abs(p1 - q1)
vqadd.u8 q9, q9, q9 ; abs(p0 - q0) * 2
@ -102,9 +98,6 @@
vld1.u8 {q0}, [r12]!
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -113,26 +106,20 @@
;;;;;;;;;;;;;;
vld1.u8 {q10}, [r12]!
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q11, d15, d13
vand q3, q3, q9
vmovl.u8 q4, d20
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
vorr q14, q13, q14 ; q14: vp8_hevmask
;vmul.i8 q2, q2, q10 ; 3 * ( qs0 - ps0)
vmul.i16 q2, q2, q4 ; 3 * ( qs0 - ps0)
vmul.i16 q11, q11, q4
vand q1, q1, q14 ; vp8_filter &= hev
vand q15, q15, q3 ; q15: vp8_filter_mask
;;
;vld1.u8 {q4}, [r12]! ;no need 7 any more
vand q15, q15, q9 ; vp8_filter_mask
;vqadd.s8 q1, q1, q2
vaddw.s8 q2, q2, d2
vaddw.s8 q11, q11, d3
@ -143,21 +130,6 @@
;;
vand q1, q1, q15 ; vp8_filter &= mask
;;
;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q1, q4 ; s = vp8_filter & 7
; vqadd.s8 q1, q1, q9 ; vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
;;;;
; vshr.s8 q1, q1, #3 ; vp8_filter >>= 3
; vceq.i8 q2, q2, q9 ; s = (s==4)*-1
;;
; ;calculate output
; vqsub.s8 q10, q7, q1 ; u = vp8_signed_char_clamp(qs0 - vp8_filter)
; vqadd.s8 q11, q2, q1 ; u = vp8_signed_char_clamp(s + vp8_filter)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; q10=3
vqadd.s8 q2, q1, q10 ; Filter2 = vp8_signed_char_clamp(vp8_filter+3)
vqadd.s8 q1, q1, q9 ; Filter1 = vp8_signed_char_clamp(vp8_filter+4)
vshr.s8 q2, q2, #3 ; Filter2 >>= 3
@ -178,7 +150,6 @@
;
vqadd.s8 q13, q5, q1 ; u = vp8_signed_char_clamp(ps1 + vp8_filter)
;vqadd.s8 q11, q6, q11 ; u = vp8_signed_char_clamp(ps0 + u)
vqsub.s8 q12, q8, q1 ; u = vp8_signed_char_clamp(qs1 - vp8_filter)
veor q7, q10, q0 ; *oq0 = u^0x80

56
vp8/common/arm/neon/mbloopfilterhorizontaledge_uv_neon.asm
View File

@ -52,8 +52,7 @@
ldr r12, _mbhlfuv_coeff_
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
vabd.u8 q13, q5, q6 ; abs(p1 - p0)
@ -61,29 +60,25 @@
vabd.u8 q3, q9, q8 ; abs(q2 - q1)
vabd.u8 q0, q10, q9 ; abs(q3 - q2)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q0, q1, q0 ; (abs(q3 - q2) > limit)*-1
vand q15, q15, q12
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q0
vmax.u8 q15, q11, q12
vabd.u8 q12, q6, q7 ; abs(p0 - q0)
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vld1.s8 {d4[], d5[]}, [r2] ; flimit
vand q10, q10, q11
vand q3, q3, q0
vld1.u8 {q0}, [r12]!
vadd.u8 q2, q2, q2 ; flimit * 2
vadd.u8 q2, q2, q1 ; flimit * 2 + limit
vcge.u8 q15, q1, q15
vabd.u8 q1, q5, q8 ; abs(p1 - q1)
vqadd.u8 q12, q12, q12 ; abs(p0 - q0) * 2
@ -91,8 +86,6 @@
vqadd.u8 q12, q12, q1 ; abs(p0 - q0) * 2 + abs(p1 - q1) / 2
vcge.u8 q12, q2, q12 ; (abs(p0 - q0)*2 + abs(p1 - q1)/2 > flimit*2 + limit)*-1
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -103,29 +96,23 @@
;;;;;;;;;;;;;
vorr q14, q13, q14 ; q14: vp8_hevmask
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q13, d15, d13
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
;vadd.s8 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q11, q13, q13
vand q15, q15, q12 ; vp8_filter_mask
vand q3, q3, q12
;vadd.s8 q2, q2, q10
vadd.s16 q2, q2, q10
vadd.s16 q13, q13, q11
vld1.u8 {q12}, [r12]! ;#3
;vqadd.s8 q1, q1, q2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q2, q2, d2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q13, q13, d3
vand q15, q15, q3 ; q15: vp8_filter_mask
vld1.u8 {q11}, [r12]! ;#4
vqmovn.s16 d2, q2 ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
@ -139,32 +126,7 @@
vand q13, q1, q14 ; Filter2: q13; Filter2 &= hev
vld1.u8 {d7}, [r12]! ;#9
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q13, q12 ; s = Filter2 & 7
; vqadd.s8 q13, q13, q11 ; Filter2 = vp8_signed_char_clamp(Filter2+4)
; vld1.u8 {d6}, [r12]! ;#18
; sub r0, r0, r1, lsl #3
; sub r3, r3, r1, lsl #3
; vshr.s8 q13, q13, #3 ; Filter2 >>= 3
; vceq.i8 q2, q2, q11 ; s = (s==4)*-1
; add r0, r0, r1
; add r3, r3, r1
; vqsub.s8 q7, q7, q13 ; qs0 = vp8_signed_char_clamp(qs0 - Filter2)
; vqadd.s8 q11, q2, q13 ; u = vp8_signed_char_clamp(s + Filter2)
; vld1.u8 {d5}, [r12]! ;#27
; vmov q10, q15
; vmov q12, q15
; vqadd.s8 q6, q6, q11 ; ps0 = vp8_signed_char_clamp(ps0 + u)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vqadd.s8 q2, q13, q11 ; Filter1 = vp8_signed_char_clamp(Filter2+4)
vqadd.s8 q13, q13, q12 ; Filter2 = vp8_signed_char_clamp(Filter2+3)

54
vp8/common/arm/neon/mbloopfilterhorizontaledge_y_neon.asm
View File

@ -36,8 +36,7 @@
ldr r12, _mbhlfy_coeff_
vld1.u8 {q6}, [r0], r1 ; p0
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vld1.u8 {q7}, [r0], r1 ; q0
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
@ -49,29 +48,25 @@
vabd.u8 q3, q9, q8 ; abs(q2 - q1)
vabd.u8 q0, q10, q9 ; abs(q3 - q2)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q0, q1, q0 ; (abs(q3 - q2) > limit)*-1
vand q15, q15, q12
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q0
vmax.u8 q15, q11, q12
vabd.u8 q12, q6, q7 ; abs(p0 - q0)
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vld1.s8 {d4[], d5[]}, [r2] ; flimit
vand q10, q10, q11
vand q3, q3, q0
vld1.u8 {q0}, [r12]!
vadd.u8 q2, q2, q2 ; flimit * 2
vadd.u8 q2, q2, q1 ; flimit * 2 + limit
vcge.u8 q15, q1, q15
vabd.u8 q1, q5, q8 ; abs(p1 - q1)
vqadd.u8 q12, q12, q12 ; abs(p0 - q0) * 2
@ -79,8 +74,6 @@
vqadd.u8 q12, q12, q1 ; abs(p0 - q0) * 2 + abs(p1 - q1) / 2
vcge.u8 q12, q2, q12 ; (abs(p0 - q0)*2 + abs(p1 - q1)/2 > flimit*2 + limit)*-1
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -91,29 +84,23 @@
;;;;;;;;;;;;;
vorr q14, q13, q14 ; q14: vp8_hevmask
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q13, d15, d13
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
;vadd.s8 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q11, q13, q13
vand q15, q15, q12 ; vp8_filter_mask
vand q3, q3, q12
;vadd.s8 q2, q2, q10
vadd.s16 q2, q2, q10
vadd.s16 q13, q13, q11
vld1.u8 {q12}, [r12]! ;#3
;vqadd.s8 q1, q1, q2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q2, q2, d2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q13, q13, d3
vand q15, q15, q3 ; q15: vp8_filter_mask
vld1.u8 {q11}, [r12]! ;#4
vqmovn.s16 d2, q2 ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
@ -129,29 +116,6 @@
vld1.u8 {d7}, [r12]! ;#9
sub r0, r0, r1, lsl #3
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q13, q12 ; s = Filter2 & 7
; vqadd.s8 q13, q13, q11 ; Filter2 = vp8_signed_char_clamp(Filter2+4)
; vld1.u8 {d6}, [r12]! ;#18
; add r0, r0, r1
; add r2, r0, r1
; vshr.s8 q13, q13, #3 ; Filter2 >>= 3
; vceq.i8 q2, q2, q11 ; s = (s==4)*-1
; add r3, r2, r1
; vqsub.s8 q7, q7, q13 ; qs0 = vp8_signed_char_clamp(qs0 - Filter2)
; vqadd.s8 q11, q2, q13 ; u = vp8_signed_char_clamp(s + Filter2)
; vld1.u8 {d5}, [r12]! ;#27
; vmov q10, q15
; vmov q12, q15
; vqadd.s8 q6, q6, q11 ; ps0 = vp8_signed_char_clamp(ps0 + u)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vqadd.s8 q2, q13, q11 ; Filter1 = vp8_signed_char_clamp(Filter2+4)
vqadd.s8 q13, q13, q12 ; Filter2 = vp8_signed_char_clamp(Filter2+3)

53
vp8/common/arm/neon/mbloopfilterverticaledge_uv_neon.asm
View File

@ -71,8 +71,7 @@
ldr r12, _mbvlfuv_coeff_
vst1.u8 {q10}, [sp]!
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
vabd.u8 q13, q5, q6 ; abs(p1 - p0)
@ -80,29 +79,25 @@
vabd.u8 q3, q9, q8 ; abs(q2 - q1)
vabd.u8 q0, q10, q9 ; abs(q3 - q2)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q0, q1, q0 ; (abs(q3 - q2) > limit)*-1
vand q15, q15, q12
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q0
vmax.u8 q15, q11, q12
vabd.u8 q12, q6, q7 ; abs(p0 - q0)
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vld1.s8 {d4[], d5[]}, [r2] ; flimit
vand q10, q10, q11
vand q3, q3, q0
vld1.u8 {q0}, [r12]!
vadd.u8 q2, q2, q2 ; flimit * 2
vadd.u8 q2, q2, q1 ; flimit * 2 + limit
vcge.u8 q15, q1, q15
vabd.u8 q1, q5, q8 ; abs(p1 - q1)
vqadd.u8 q12, q12, q12 ; abs(p0 - q0) * 2
@ -110,8 +105,6 @@
vqadd.u8 q12, q12, q1 ; abs(p0 - q0) * 2 + abs(p1 - q1) / 2
vcge.u8 q12, q2, q12 ; (abs(p0 - q0)*2 + abs(p1 - q1)/2 > flimit*2 + limit)*-1
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -122,29 +115,23 @@
;;;;;;;;;;;;;
vorr q14, q13, q14 ; q14: vp8_hevmask
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q13, d15, d13
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
;vadd.s8 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q11, q13, q13
vand q15, q15, q12 ; vp8_filter_mask
vand q3, q3, q12
;vadd.s8 q2, q2, q10
vadd.s16 q2, q2, q10
vadd.s16 q13, q13, q11
vld1.u8 {q12}, [r12]! ;#3
;vqadd.s8 q1, q1, q2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q2, q2, d2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q13, q13, d3
vand q15, q15, q3 ; q15: vp8_filter_mask
vld1.u8 {q11}, [r12]! ;#4
vqmovn.s16 d2, q2 ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
@ -160,28 +147,6 @@
vld1.u8 {d7}, [r12]! ;#9
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q13, q12 ; s = Filter2 & 7
; vqadd.s8 q13, q13, q11 ; Filter2 = vp8_signed_char_clamp(Filter2+4)
; vld1.u8 {d6}, [r12]! ;#18
; sub r0, r0, r1, lsl #3
; sub r3, r3, r1, lsl #3
; sub sp, sp, #32
; vshr.s8 q13, q13, #3 ; Filter2 >>= 3
; vceq.i8 q2, q2, q11 ; s = (s==4)*-1
; vqsub.s8 q7, q7, q13 ; qs0 = vp8_signed_char_clamp(qs0 - Filter2)
; vqadd.s8 q11, q2, q13 ; u = vp8_signed_char_clamp(s + Filter2)
; vld1.u8 {d5}, [r12]! ;#27
; vmov q10, q15
; vmov q12, q15
; vqadd.s8 q6, q6, q11 ; ps0 = vp8_signed_char_clamp(ps0 + u)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vqadd.s8 q2, q13, q11 ; Filter1 = vp8_signed_char_clamp(Filter2+4)
vqadd.s8 q13, q13, q12 ; Filter2 = vp8_signed_char_clamp(Filter2+3)

55
vp8/common/arm/neon/mbloopfilterverticaledge_y_neon.asm
View File

@ -69,8 +69,7 @@
ldr r12, _mbvlfy_coeff_
vst1.u8 {q10}, [sp]!
;vp8_filter_mask() function
;vp8_hevmask() function
; vp8_filter_mask
vabd.u8 q11, q3, q4 ; abs(p3 - p2)
vabd.u8 q12, q4, q5 ; abs(p2 - p1)
vabd.u8 q13, q5, q6 ; abs(p1 - p0)
@ -78,29 +77,25 @@
vabd.u8 q3, q9, q8 ; abs(q2 - q1)
vabd.u8 q0, q10, q9 ; abs(q3 - q2)
vcge.u8 q15, q1, q11 ; (abs(p3 - p2) > limit)*-1
vcge.u8 q12, q1, q12 ; (abs(p2 - p1) > limit)*-1
vcge.u8 q10, q1, q13 ; (abs(p1 - p0) > limit)*-1
vcge.u8 q11, q1, q14 ; (abs(q1 - q0) > limit)*-1
vcge.u8 q3, q1, q3 ; (abs(q2 - q1) > limit)*-1
vcge.u8 q0, q1, q0 ; (abs(q3 - q2) > limit)*-1
vand q15, q15, q12
vmax.u8 q11, q11, q12
vmax.u8 q12, q13, q14
vmax.u8 q3, q3, q0
vmax.u8 q15, q11, q12
vabd.u8 q12, q6, q7 ; abs(p0 - q0)
; vp8_hevmask
vcgt.u8 q13, q13, q2 ; (abs(p1 - p0) > thresh)*-1
vcgt.u8 q14, q14, q2 ; (abs(q1 - q0) > thresh)*-1
vmax.u8 q15, q15, q3
vld1.s8 {d4[], d5[]}, [r2] ; flimit
vand q10, q10, q11
vand q3, q3, q0
vld1.u8 {q0}, [r12]!
vadd.u8 q2, q2, q2 ; flimit * 2
vadd.u8 q2, q2, q1 ; flimit * 2 + limit
vcge.u8 q15, q1, q15
vabd.u8 q1, q5, q8 ; abs(p1 - q1)
vqadd.u8 q12, q12, q12 ; abs(p0 - q0) * 2
@ -108,8 +103,6 @@
vqadd.u8 q12, q12, q1 ; abs(p0 - q0) * 2 + abs(p1 - q1) / 2
vcge.u8 q12, q2, q12 ; (abs(p0 - q0)*2 + abs(p1 - q1)/2 > flimit*2 + limit)*-1
vand q15, q15, q10
;vp8_filter() function
veor q7, q7, q0 ; qs0: q0 offset to convert to a signed value
veor q6, q6, q0 ; ps0: p0 offset to convert to a signed value
@ -120,29 +113,23 @@
;;;;;;;;;;;;;
vorr q14, q13, q14 ; q14: vp8_hevmask
;vqsub.s8 q2, q7, q6 ; ( qs0 - ps0)
vsubl.s8 q2, d14, d12 ; ( qs0 - ps0)
vsubl.s8 q13, d15, d13
vqsub.s8 q1, q5, q8 ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
;vadd.s8 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q10, q2, q2 ; 3 * ( qs0 - ps0)
vadd.s16 q11, q13, q13
vand q15, q15, q12 ; vp8_filter_mask
vand q3, q3, q12
;vadd.s8 q2, q2, q10
vadd.s16 q2, q2, q10
vadd.s16 q13, q13, q11
vld1.u8 {q12}, [r12]! ;#3
;vqadd.s8 q1, q1, q2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q2, q2, d2 ; vp8_filter + 3 * ( qs0 - ps0)
vaddw.s8 q13, q13, d3
vand q15, q15, q3 ; q15: vp8_filter_mask
vld1.u8 {q11}, [r12]! ;#4
vqmovn.s16 d2, q2 ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
@ -158,30 +145,6 @@
vld1.u8 {d7}, [r12]! ;#9
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Change for VP8 from VP7
; vand q2, q13, q12 ; s = Filter2 & 7
; vqadd.s8 q13, q13, q11 ; Filter2 = vp8_signed_char_clamp(Filter2+4)
; vld1.u8 {d6}, [r12]! ;#18
; sub r0, r0, r1, lsl #4
; sub sp, sp, #32
; add r2, r0, r1
; vshr.s8 q13, q13, #3 ; Filter2 >>= 3
; vceq.i8 q2, q2, q11 ; s = (s==4)*-1
; add r3, r2, r1
; vqsub.s8 q7, q7, q13 ; qs0 = vp8_signed_char_clamp(qs0 - Filter2)
; vqadd.s8 q11, q2, q13 ; u = vp8_signed_char_clamp(s + Filter2)
; vld1.u8 {d5}, [r12]! ;#27
; vmov q10, q15
; vmov q12, q15
; vqadd.s8 q6, q6, q11 ; ps0 = vp8_signed_char_clamp(ps0 + u)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vqadd.s8 q2, q13, q11 ; Filter1 = vp8_signed_char_clamp(Filter2+4)
vqadd.s8 q13, q13, q12 ; Filter2 = vp8_signed_char_clamp(Filter2+3)

0
vp8/common/reconintra_mt.h → vp8/decoder/reconintra_mt.h
View File

29
vp8/encoder/onyx_if.c
View File

@ -1330,11 +1330,6 @@ void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
cpi->per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
cpi->av_per_frame_bandwidth = (int)(cpi->oxcf.target_bandwidth / cpi->output_frame_rate);
cpi->min_frame_bandwidth = (int)(cpi->av_per_frame_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
cpi->max_gf_interval = (int)(cpi->output_frame_rate / 2) + 2;
//cpi->max_gf_interval = (int)(cpi->output_frame_rate * 2 / 3) + 1;
@ -1580,6 +1575,10 @@ void vp8_init_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
cpi->active_best_quality = cpi->oxcf.best_allowed_q;
cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
cpi->total_actual_bits = 0;
cpi->total_target_vs_actual = 0;
@ -1858,6 +1857,10 @@ void vp8_change_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
cpi->active_best_quality = cpi->oxcf.best_allowed_q;
cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
cpi->rolling_target_bits = cpi->av_per_frame_bandwidth;
cpi->rolling_actual_bits = cpi->av_per_frame_bandwidth;
cpi->long_rolling_target_bits = cpi->av_per_frame_bandwidth;
cpi->long_rolling_actual_bits = cpi->av_per_frame_bandwidth;
cpi->total_actual_bits = 0;
cpi->total_target_vs_actual = 0;
@ -2676,6 +2679,8 @@ int vp8_update_entropy(VP8_PTR comp, int update)
return 0;
}
#if OUTPUT_YUV_SRC
void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
{
FILE *yuv_file = fopen(name, "ab");
@ -2711,6 +2716,8 @@ void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
fclose(yuv_file);
}
#endif
static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
{
@ -4355,12 +4362,13 @@ static void encode_frame_to_data_rate(VP8_COMP *cpi, unsigned long *size, unsign
if (cm->frame_type == KEY_FRAME)
cm->refresh_last_frame = 1;
if (0)
#if 0
{
FILE *f = fopen("gfactive.stt", "a");
fprintf(f, "%8d %8d %8d %8d %8d\n", cm->current_video_frame, (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols), cpi->this_iiratio, cpi->next_iiratio, cm->refresh_golden_frame);
fclose(f);
}
#endif
// For inter frames the current default behaviour is that when cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
// This is purely an encoder descision at present.
@ -4604,9 +4612,7 @@ static void encode_frame_to_data_rate(VP8_COMP *cpi, unsigned long *size, unsign
}
}
#if CONFIG_PSNR
if (0)
#if 0 && CONFIG_PSNR
{
FILE *f = fopen("tmp.stt", "a");
@ -4731,7 +4737,7 @@ static void encode_frame_to_data_rate(VP8_COMP *cpi, unsigned long *size, unsign
if (0)
#if 0
{
char filename[512];
FILE *recon_file;
@ -4741,6 +4747,7 @@ static void encode_frame_to_data_rate(VP8_COMP *cpi, unsigned long *size, unsign
cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
fclose(recon_file);
}
#endif
// DEBUG
//vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
@ -4800,8 +4807,6 @@ void vp8_check_gf_quality(VP8_COMP *cpi)
}
#if 0
if (0)
{
FILE *f = fopen("gfneeded.stt", "a");
fprintf(f, "%10d %10d %10d %10d %10ld \n",