gmane.comp.video.x264.devel

Re: Different pic_init_qp_minus26 cause stitching tofail.

Jason Garrett-Glaser — 2013-05-22T15:29:22

Is the video not allowed to keep the PPS and SPSs from each of the
stitched sections?

If not, maybe I could add a --stitchable option?

Jason
_______________________________________________
x264-devel mailing list
x264-devel< at >videolan.org
http://mailman.videolan.org/listinfo/x264-devel

Different pic_init_qp_minus26 cause stitching to fail.

Anders Rein — 2013-05-22T09:02:00

Hi,

I am working on a software which transcodes clips and commercial to 
different resolution and serve the correct content to various media 
devices. We've been using x264 via ffmpeg for encoding h264. Recently we 
updated x264 from snapshot-20120705 to snapshot-20130303. This caused 
our stitching of commercial and video content to fail.

The stitching fails because the pic_init_qp_minus26 in the 
picture_parameter_set differs between the clips. The results vary from 
foggy and saturate results to complete crash (depending on the decoder).

Re-encoding is not an option since content needs to be stitched on the 
fly. I made a remuxer that changed the PPS/SPS Id before stitching, but 
only a hand full of the players tested supported multiple SPS/PPS in a 
video (ffplay and android go, iphone and vlc no).

I was wondering if maybe it would be a good idea to allow to manually 
set the pic_init_qp_minus26 via a parameter? What is the gain from 
setting the pic_init_qp_minus26 value closer to the average qp? fe

achieving "contrained VBR" using crf,vbv and client buffering - wise?

Ran RanUser — 2013-05-22T00:50:27

Hello,

I don't have a vbv aware stream analyzer tool, but the following seems to
be working in my test environment when I simulate lowered download speeds.

Please let me know if my assumptions are incorrect and if I'm asking for
trouble :)

Objective:

- need to provide videos such that a user with X-kbps can view (using
RTMP/RTSP/HLS or other streaming protocols)

- achieving a "constrained VBR" effect by using crf, vbv-maxrate,
vbv-bufsize

Test:

- I want to target users that have 800kbps or higher download bandwidth
- will use 64kbps audio
- use crf 20
- vbv-maxrate=730
- vbv-bufsize=2190
- client is using a Flash player with 5 second client buffer

Assumptions:

- during any given second, the peak video bitrate  will not exceed 2190kbps
- for any 3 second stretch, the average video bit rate will not exceed
730kbps
- my client (Flash player) buffer of 5 seconds will be sufficient to handle
1390kbps additional bandwidth requirement that could occur during any 3
second period (2190 - 800kbps)

Since I do

x86: Don't use explicitly aligned versions of SAD onAVX CPUs

Henrik Gramner — 2013-05-20T21:06:47

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Fri May  3 23:06:10 2013 +0200| [b4be6e56629cf8fdcf53adc6b879969d8f6760b3] | committer: Jason Garrett-Glaser

x86: Don't use explicitly aligned versions of SAD on AVX CPUs

On modern CPUs movdqu isn't slower than movdqa when used on aligned data and using the same code in both cases saves cache.

This was already done for the high bit-depth AVX2 implementation but the aligned version still exists as dead code so remove that.

---

 common/pixel.c         |    2 ++
 common/x86/pixel.h     |    1 -
 common/x86/sad16-a.asm |    3 ---
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/common/pixel.c b/common/pixel.c
index 145fac7..2b323cb 100644
--- a/common/pixel.c
+++ b/common/pixel.c
< at >< at > -966,6 +966,7 < at >< at > void x264_pixel_init( int cpu, x264_pixel_function_t *pixf )
     }
     if( cpu&X264_CPU_AVX )
     {
+        INIT5_NAME( sad_aligned, sad, _ssse3 ); /* AVX-capable CPUs doesn't benefit from an aligned version */
         INIT_ADS( _a

x86: Add missing initializations for high bit-depthsad_aligned

Henrik Gramner — 2013-05-20T21:06:47

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Fri May  3 20:18:03 2013 +0200| [99f553ec300d928d23522304ebf4818574b85ed3] | committer: Jason Garrett-Glaser

x86: Add missing initializations for high bit-depth sad_aligned

---

 common/pixel.c |    3 +++
 1 file changed, 3 insertions(+)

diff --git a/common/pixel.c b/common/pixel.c
index a6f4ebc..145fac7 100644
--- a/common/pixel.c
+++ b/common/pixel.c
< at >< at > -845,6 +845,7 < at >< at > void x264_pixel_init( int cpu, x264_pixel_function_t *pixf )
     if( cpu&X264_CPU_MMX2 )
     {
         INIT7( sad, _mmx2 );
+        INIT7_NAME( sad_aligned, sad, _mmx2 );
         INIT7( sad_x3, _mmx2 );
         INIT7( sad_x4, _mmx2 );
         INIT8( satd, _mmx2 );
< at >< at > -923,6 +924,8 < at >< at > void x264_pixel_init( int cpu, x264_pixel_function_t *pixf )
     if( cpu&X264_CPU_SSSE3 )
     {
         INIT4_NAME( sad_aligned, sad, _ssse3_aligned );
+        pixf->sad_aligned[PIXEL_4x4] = x264_pixel_sad_4x4_ssse3;
+        pixf->sad_aligned[PIXEL_4x8] = x264_pixel_sad_4x8_ssse3;

x264 Development Newsletter: Vol 37

Jason Garrett-Glaser — 2013-05-20T21:06:46

This is the thirty-seventh x264 development newsletter. This is a
regular email containing updates on fixes and improvements in the most
recent x264 push, along with updates on what's coming next.  Previous
versions can be found in the mailing list archives.

Fixes:

Fix an invalid memcpy in sliced-threads that sometimes used src==dst;
this probably didn't break anything, but valgrind complains and it's
technically wrong.

Fix a stack alignment bug in checkasm and use 64-bit cycle counters to
avoid overflows that could occur in some tests.

x86inc: Remove .rodata kludges; they're no longer necessary and could
cause other problems.

Improvements:

x86: add Jaguar CPU detection.

x86inc: utilize the shadow space on win64 to avoid stack pointer
manipulation in some functions.

x86: 32-byte align the stack if possible, avoiding explicit alignment
routines in ALIGNED_ARRAY for AVX2-aligned arrays.

x86: Various optimizations and a bunch of new AVX2 functions,
especially for high bit depth.

OpenCL refactoring: au

OpenCL support improvement/refactoring

Anton Mitrofanov — 2013-05-20T21:06:51

x264 | branch: master | Anton Mitrofanov <BugMaster< at >narod.ru> | Mon May  6 22:51:11 2013 +0400| [a3ac64b8b467eea1264c0053022893bc84b2e9a2] | committer: Jason Garrett-Glaser

OpenCL support improvement/refactoring

Autoload the OpenCL library so that it's not required to run an openCL-enabled
build of x264.

Update X264_BUILD, which should have been changed with the first patch.

---

 Makefile               |   24 +-
 common/common.c        |    4 +-
 common/common.h        |    7 +-
 common/frame.c         |    4 +
 common/opencl.c        |  369 +++++++++-----
 common/opencl.h        |  696 ++++++++++++++++++++++++++-
 configure              |   85 ++--
 encoder/encoder.c      |   28 +-
 encoder/slicetype-cl.c |   38 +-
 extras/cl.h            | 1209 ++++++++++++++++++++++++++++++++++++++++++++++
 extras/cl_platform.h   | 1254 ++++++++++++++++++++++++++++++++++++++++++++++++
 x264.h                 |    2 +-
 12 files changed, 3473 insertions(+), 247 deletions(-)

Diff:   http://git.videolan.org/gitweb.cgi/

x86: shave a few instructions off AVX deblock

Jason Garrett-Glaser — 2013-05-20T21:06:51

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Thu May 16 13:51:37 2013 -0700| [c47347c01eb4d9933e2d9705f44707dbb396f611] | committer: Jason Garrett-Glaser

x86: shave a few instructions off AVX deblock

---

 common/x86/const-a.asm   |    2 ++
 common/x86/dct-a.asm     |   14 ++++-----
 common/x86/deblock-a.asm |   71 ++++++++++++++++++++++++++--------------------
 3 files changed, 49 insertions(+), 38 deletions(-)

diff --git a/common/x86/const-a.asm b/common/x86/const-a.asm
index e8428d8..ea04213 100644
--- a/common/x86/const-a.asm
+++ b/common/x86/const-a.asm
< at >< at > -38,6 +38,8 < at >< at > const pw_00ff,     times 16 dw 0x00ff
 const pw_pixel_max,times 16 dw ((1 << BIT_DEPTH)-1)
 const pd_1,        times 8 dd 1
 const deinterleave_shufd, dd 0,4,1,5,2,6,3,7
+const pb_unpackbd1, times 2 db 0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3
+const pb_unpackbd2, times 2 db 4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7
 
 const pb_01,       times  8 db 0,1
 const pb_0,        times 16 db 0
diff --git a/common/x86/dct-a.asm b/common/x86/d

x86: AVX2 dequant_4x4_dc

Henrik Gramner — 2013-05-20T21:06:51

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Tue May 14 18:57:40 2013 +0200| [b547a4ea1169411610855002db9a8182b1e73314] | committer: Jason Garrett-Glaser

x86: AVX2 dequant_4x4_dc

---

 common/quant.c         |    5 ++--
 common/x86/quant-a.asm |   75 +++++++++++++++++++++++++++---------------------
 common/x86/quant.h     |    1 +
 3 files changed, 47 insertions(+), 34 deletions(-)

diff --git a/common/quant.c b/common/quant.c
index 5d37f07..7aa851e 100644
--- a/common/quant.c
+++ b/common/quant.c
< at >< at > -545,6 +545,7 < at >< at > void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf )
         pf->quant_4x4x4 = x264_quant_4x4x4_avx2;
         pf->dequant_4x4 = x264_dequant_4x4_avx2;
         pf->dequant_8x8 = x264_dequant_8x8_avx2;
+        pf->dequant_4x4_dc = x264_dequant_4x4dc_avx2;
         pf->denoise_dct = x264_denoise_dct_avx2;
     }
 #endif // HAVE_MMX
< at >< at > -691,10 +692,9 < at >< at > void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf )
         pf->quant_4x4_dc = x264_quant

x86: AVX2 high bit-depth dequant

Henrik Gramner — 2013-05-20T21:06:50

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Tue May 14 18:53:12 2013 +0200| [907573d3f7873b7600cc94d1e287d52628e11766] | committer: Jason Garrett-Glaser

x86: AVX2 high bit-depth dequant

---

 common/quant.c         |    2 ++
 common/x86/quant-a.asm |   70 +++++++++++++++++++++++++++---------------------
 2 files changed, 41 insertions(+), 31 deletions(-)

diff --git a/common/quant.c b/common/quant.c
index 57151bb..5d37f07 100644
--- a/common/quant.c
+++ b/common/quant.c
< at >< at > -543,6 +543,8 < at >< at > void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf )
         pf->quant_4x4_dc = x264_quant_4x4_dc_avx2;
         pf->quant_8x8 = x264_quant_8x8_avx2;
         pf->quant_4x4x4 = x264_quant_4x4x4_avx2;
+        pf->dequant_4x4 = x264_dequant_4x4_avx2;
+        pf->dequant_8x8 = x264_dequant_8x8_avx2;
         pf->denoise_dct = x264_denoise_dct_avx2;
     }
 #endif // HAVE_MMX
diff --git a/common/x86/quant-a.asm b/common/x86/quant-a.asm
index d77c282..8a7f8f9 100644
--- a/common/x86/quant

x86-64: 64-bit variant of AVX2 hpel_filter

Jason Garrett-Glaser — 2013-05-20T21:06:50

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Thu May  9 17:20:05 2013 -0700| [442c6a420f8727d2f4087e9f3f317fb1774b9262] | committer: Jason Garrett-Glaser

x86-64: 64-bit variant of AVX2 hpel_filter

~5% faster than 32-bit.

---

 common/x86/mc-a2.asm   |   64 ++++++++++++++++++++++++++++++++++--------------
 common/x86/mc-c.c      |    3 ++-
 common/x86/x86util.asm |   13 +++++++++-
 3 files changed, 59 insertions(+), 21 deletions(-)

diff --git a/common/x86/mc-a2.asm b/common/x86/mc-a2.asm
index 8c3bd46..ad1f2ec 100644
--- a/common/x86/mc-a2.asm
+++ b/common/x86/mc-a2.asm
< at >< at > -37,6 +37,7 < at >< at > filt_mul15: times 16 db 1, -5
 filt_mul51: times 16 db -5, 1
 hpel_shuf: times 2 db 0,8,1,9,2,10,3,11,4,12,5,13,6,14,7,15
 deinterleave_shuf: times 2 db 0,2,4,6,8,10,12,14,1,3,5,7,9,11,13,15
+
 %if HIGH_BIT_DEPTH
 deinterleave_shuf32a: SHUFFLE_MASK_W 0,2,4,6,8,10,12,14
 deinterleave_shuf32b: SHUFFLE_MASK_W 1,3,5,7,9,11,13,15
< at >< at > -642,7 +643,6 < at >< at > INIT_XMM avx
 HPEL_C
 HPEL_V 0
 HPEL_H
-%endif
 INIT_YMM av

x86: AVX2 high bit-depth quant

Henrik Gramner — 2013-05-20T21:06:49

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Sat May  4 18:48:58 2013 +0200| [db95d6af63bec7839b3d3e1f2eb67b8689dc8170] | committer: Jason Garrett-Glaser

x86: AVX2 high bit-depth quant

quant_4x4: 13->6 cycles
quant_4x4_dc: 14->8 cycles
quant_8x8: 47->24 cycles
quant_4x4x4: 48->25 cycles

---

 common/quant.c         |    7 +++++++
 common/x86/quant-a.asm |   34 +++++++++++++++++++++++++++++-----
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/common/quant.c b/common/quant.c
index cffd8e8..d4fd405 100644
--- a/common/quant.c
+++ b/common/quant.c
< at >< at > -537,6 +537,13 < at >< at > void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf )
             pf->dequant_8x8 = x264_dequant_8x8_xop;
         }
     }
+    if( cpu&X264_CPU_AVX2 )
+    {
+        pf->quant_4x4 = x264_quant_4x4_avx2;
+        pf->quant_4x4_dc = x264_quant_4x4_dc_avx2;
+        pf->quant_8x8 = x264_quant_8x8_avx2;
+        pf->quant_4x4x4 = x264_quant_4x4x4_avx2;
+    }
 #endif // HAVE_MMX
 #else // !HIGH_B

x86: AVX2 high bit-depth denoise_dct

Henrik Gramner — 2013-05-20T21:06:50

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Mon May  6 18:41:24 2013 +0200| [26a6451591cd7cd25fcfeeacee3850e5dd7a7f7e] | committer: Jason Garrett-Glaser

x86: AVX2 high bit-depth denoise_dct

28->15 cycles

Also reorder instructions to use fewer registers, 3 cycles faster on Ivy Bridge with 64-bit Windows.

---

 common/quant.c         |    1 +
 common/x86/quant-a.asm |   26 +++++++++++++-------------
 2 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/common/quant.c b/common/quant.c
index d4fd405..57151bb 100644
--- a/common/quant.c
+++ b/common/quant.c
< at >< at > -543,6 +543,7 < at >< at > void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf )
         pf->quant_4x4_dc = x264_quant_4x4_dc_avx2;
         pf->quant_8x8 = x264_quant_8x8_avx2;
         pf->quant_4x4x4 = x264_quant_4x4x4_avx2;
+        pf->denoise_dct = x264_denoise_dct_avx2;
     }
 #endif // HAVE_MMX
 #else // !HIGH_BIT_DEPTH
diff --git a/common/x86/quant-a.asm b/common/x86/quant-a.asm
index 3f7e9b3..d77c282 10064

x86: AVX2 add16x16_idct_dc

Jason Garrett-Glaser — 2013-05-20T21:06:49

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Wed May  1 14:32:11 2013 -0700| [327386f70836507cb44266e5d71bd1d744fe3d78] | committer: Jason Garrett-Glaser

x86: AVX2 add16x16_idct_dc

27 -> 19 cycles

---

 common/dct.c         |    1 +
 common/x86/dct-a.asm |   50 +++++++++++++++++++++++++++++++++++++++++++-------
 common/x86/dct.h     |    1 +
 3 files changed, 45 insertions(+), 7 deletions(-)

diff --git a/common/dct.c b/common/dct.c
index e0219ec..52ef9be 100644
--- a/common/dct.c
+++ b/common/dct.c
< at >< at > -697,6 +697,7 < at >< at > void x264_dct_init( int cpu, x264_dct_function_t *dctf )
         dctf->add16x16_idct    = x264_add16x16_idct_avx2;
         dctf->sub8x8_dct       = x264_sub8x8_dct_avx2;
         dctf->sub16x16_dct     = x264_sub16x16_dct_avx2;
+        dctf->add16x16_idct_dc = x264_add16x16_idct_dc_avx2;
 #if ARCH_X86_64
         dctf->sub16x16_dct8    = x264_sub16x16_dct8_avx2;
 #endif
diff --git a/common/x86/dct-a.asm b/common/x86/dct-a.asm
index 52b287f..a3e2ce6 100644
--- a/common/

x86: faster AVX2 quant_4x4x4

Jason Garrett-Glaser — 2013-05-20T21:06:49

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Mon Apr 29 16:16:54 2013 -0700| [c82db4ed07d4a69a84ac99d5e79e32f61141494f] | committer: Jason Garrett-Glaser

x86: faster AVX2 quant_4x4x4

10->9 cycles

---

 common/x86/quant-a.asm |   22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/common/x86/quant-a.asm b/common/x86/quant-a.asm
index 6f4b5f9..fbe2d79 100644
--- a/common/x86/quant-a.asm
+++ b/common/x86/quant-a.asm
< at >< at > -470,25 +470,23 < at >< at > QUANT_AC quant_8x8, 4
 QUANT_DC quant_4x4_dc, 1, 6
 
 INIT_YMM avx2
-cglobal quant_4x4x4, 3,3,7
+cglobal quant_4x4x4, 3,3,6
     mova      m2, [r1]
     mova      m3, [r2]
     QUANT_ONE [r0+ 0], m2, m3, 0, 4
     QUANT_ONE [r0+32], m2, m3, 0, 5
     packssdw  m4, m5
     QUANT_ONE [r0+64], m2, m3, 0, 5
-    QUANT_ONE [r0+96], m2, m3, 0, 6
-    packssdw  m5, m6
+    QUANT_ONE [r0+96], m2, m3, 0, 1
+    packssdw  m5, m1
     packssdw  m4, m5
-    vextracti128 xm5, m4, 1
-    por      xm4, xm5
-    packssdw xm4, xm4
-

x86: AVX2 high bit-depth intra_sad_x3_8x8

Henrik Gramner — 2013-05-20T21:06:48

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Sun Apr 28 11:11:03 2013 +0200| [2c0bca3f798e20133f61c3517202942e873e00d6] | committer: Jason Garrett-Glaser

x86: AVX2 high bit-depth intra_sad_x3_8x8

43->24 cycles

---

 common/pixel.c         |    1 +
 common/x86/pixel.h     |    1 +
 common/x86/sad16-a.asm |   50 ++++++++++++++++++++++++++++++++++++++++++++++++
 encoder/analyse.c      |    2 +-
 4 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/common/pixel.c b/common/pixel.c
index 2b323cb..28948b2 100644
--- a/common/pixel.c
+++ b/common/pixel.c
< at >< at > -1000,6 +1000,7 < at >< at > void x264_pixel_init( int cpu, x264_pixel_function_t *pixf )
         INIT2( sad_x4, _avx2 );
         pixf->vsad = x264_pixel_vsad_avx2;
         pixf->ssd_nv12_core = x264_pixel_ssd_nv12_core_avx2;
+        pixf->intra_sad_x3_8x8 = x264_intra_sad_x3_8x8_avx2;
     }
 #endif // HAVE_MMX
 #else // !HIGH_BIT_DEPTH
diff --git a/common/x86/pixel.h b/common/x86/pixel.h
index 555c4ec..6c06a69 100644
--- a/common/x86/pix

x86: AVX2 intra_sad_x3_8x8c

Jason Garrett-Glaser — 2013-05-20T21:06:48

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Sat Apr 27 21:03:32 2013 -0700| [b79f4a6e460b00c85f0ee67b03299bf1d15dd48c] | committer: Jason Garrett-Glaser

x86: AVX2 intra_sad_x3_8x8c

30->22 cycles

---

 common/pixel.c       |    1 +
 common/x86/pixel.h   |    1 +
 common/x86/sad-a.asm |   63 +++++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/common/pixel.c b/common/pixel.c
index 28948b2..4e6730f 100644
--- a/common/pixel.c
+++ b/common/pixel.c
< at >< at > -1304,6 +1304,7 < at >< at > void x264_pixel_init( int cpu, x264_pixel_function_t *pixf )
         pixf->var2[PIXEL_8x8]   = x264_pixel_var2_8x8_avx2;
         pixf->intra_sad_x3_16x16 = x264_intra_sad_x3_16x16_avx2;
         pixf->intra_sad_x9_8x8  = x264_intra_sad_x9_8x8_avx2;
+        pixf->intra_sad_x3_8x8c = x264_intra_sad_x3_8x8c_avx2;
         pixf->ssd_nv12_core = x264_pixel_ssd_nv12_core_avx2;
 #if ARCH_X86_64
         pixf->sa8d_satd[PIXEL_16x16] = x264_pixel_sa8d_satd_16x16_avx2;
d

x86: AVX2 deblock strength

Jason Garrett-Glaser — 2013-05-20T21:06:47

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Wed Apr 24 14:22:15 2013 -0700| [b2c30e1a470181b591619b211ae0342e9cc8aac9] | committer: Jason Garrett-Glaser

x86: AVX2 deblock strength

30->18 cycles

---

 common/deblock.c         |    7 +++++
 common/x86/deblock-a.asm |   71 +++++++++++++++++++++++++++++++++++++++++++++-
 tools/checkasm.c         |    6 ++--
 3 files changed, 80 insertions(+), 4 deletions(-)

diff --git a/common/deblock.c b/common/deblock.c
index 18ed14f..4faf66a 100644
--- a/common/deblock.c
+++ b/common/deblock.c
< at >< at > -686,6 +686,9 < at >< at > void x264_deblock_strength_ssse3( uint8_t nnz[X264_SCAN8_SIZE], int8_t ref[2][X2
 void x264_deblock_strength_avx  ( uint8_t nnz[X264_SCAN8_SIZE], int8_t ref[2][X264_SCAN8_LUMA_SIZE],
                                   int16_t mv[2][X264_SCAN8_LUMA_SIZE][2], uint8_t bs[2][8][4],
                                   int mvy_limit, int bframe );
+void x264_deblock_strength_avx2 ( uint8_t nnz[X264_SCAN8_SIZE], int8_t ref[2][X264_SCAN8_LUMA_SIZE],
+

x86: Faster high bit-depth intra_sad_x3_4x4

Henrik Gramner — 2013-05-20T21:06:47

x264 | branch: master | Henrik Gramner <henrik< at >gramner.com> | Wed May  1 17:42:48 2013 +0200| [37edf16c1955cfc9d2843024af0fa7aa6268ad90] | committer: Jason Garrett-Glaser

x86: Faster high bit-depth intra_sad_x3_4x4

20->16 cycles on Ivy Bridge

---

 common/x86/sad16-a.asm |   43 ++++++++++++++++++++++++-------------------
 encoder/analyse.c      |    2 +-
 2 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/common/x86/sad16-a.asm b/common/x86/sad16-a.asm
index 7606da3..62da7cd 100644
--- a/common/x86/sad16-a.asm
+++ b/common/x86/sad16-a.asm
< at >< at > -533,52 +533,57 < at >< at > SAD_X 4, 16,  8
 
 %macro INTRA_SAD_X3_4x4 0
 cglobal intra_sad_x3_4x4, 3,3,7
-    movq      m0, [r1-1*FDEC_STRIDEB]
+    movddup   m0, [r1-1*FDEC_STRIDEB]
     movq      m1, [r0+0*FENC_STRIDEB]
     movq      m2, [r0+2*FENC_STRIDEB]
     pshuflw   m6, m0, q1032
     paddw     m6, m0
     pshuflw   m5, m6, q2301
     paddw     m6, m5
-    punpcklqdq m6, m6       ;A+B+C+D 8 times
-    punpcklqdq m0, m0
+    punpcklqdq m6, m6       ; A+B

x86: faster SSSE3 hpel

Jason Garrett-Glaser — 2013-05-20T21:06:47

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Tue Apr 30 17:36:46 2013 -0700| [a9ed051f2bc73c9bfeff006d7328bd2bc99ce147] | committer: Jason Garrett-Glaser

x86: faster SSSE3 hpel

~7% faster using the pmulhrsw trick from mc_chroma.

---

 common/x86/const-a.asm |    1 +
 common/x86/mc-a.asm    |    2 +-
 common/x86/mc-a2.asm   |   97 +++++++++++++++++++++++++++++-------------------
 3 files changed, 61 insertions(+), 39 deletions(-)

diff --git a/common/x86/const-a.asm b/common/x86/const-a.asm
index 3a7a942..e8428d8 100644
--- a/common/x86/const-a.asm
+++ b/common/x86/const-a.asm
< at >< at > -33,6 +33,7 < at >< at > const hsub_mul,    times 16 db 1, -1
 const pw_1,        times 16 dw 1
 const pw_16,       times 16 dw 16
 const pw_32,       times 16 dw 32
+const pw_512,      times 16 dw 512
 const pw_00ff,     times 16 dw 0x00ff
 const pw_pixel_max,times 16 dw ((1 << BIT_DEPTH)-1)
 const pd_1,        times 8 dd 1
diff --git a/common/x86/mc-a.asm b/common/x86/mc-a.asm
index 477fa21..7acc366 100644
--- a/common/

x86: 32-byte align the stack if possible

Jason Garrett-Glaser — 2013-05-20T21:06:47

x264 | branch: master | Jason Garrett-Glaser <jason< at >x264.com> | Thu May  2 17:10:26 2013 -0700| [2a716040eb8b89efd92ea61ab08ecc41bf0b8623] | committer: Jason Garrett-Glaser

x86: 32-byte align the stack if possible

Avoids the need for manual 32 byte array alignment on compilers that support
-mpreferred-stack-boundary.

---

 common/cpu.h         |   14 ++++++++------
 common/osdep.h       |    6 ++++++
 common/x86/cpu-a.asm |   29 +++++++++++++++++++++++------
 configure            |    4 ++++
 4 files changed, 41 insertions(+), 12 deletions(-)

diff --git a/common/cpu.h b/common/cpu.h
index 7f76e43..27d1339 100644
--- a/common/cpu.h
+++ b/common/cpu.h
< at >< at > -48,15 +48,17 < at >< at > void     x264_cpu_sfence( void );
 void     x264_cpu_mask_misalign_sse( void );
 void     x264_safe_intel_cpu_indicator_init( void );
 
-/* kluge:
+/* kludge:
  * gcc can't give variables any greater alignment than the stack frame has.
- * We need 16 byte alignment for SSE2, so here we make sure that the stack is
- * aligned to 16 bytes.
+