From 2368b59a81003cb87869a8f01615e28bbf8326bf Mon Sep 17 00:00:00 2001

From: Ilya Kurdyukov <jpegqs@gmail.com>

Date: Fri, 26 Mar 2021 14:57:57 +0700

Subject: [PATCH] ffmpeg-4.3.1 e2k support

---

 configure                            |   20 +-

 libavcodec/audiodsp.c                |    2 +

 libavcodec/audiodsp.h                |    1 +

 libavcodec/blockdsp.c                |    2 +

 libavcodec/blockdsp.h                |    1 +

 libavcodec/e2k/Makefile              |   31 +

 libavcodec/e2k/audiodsp.c            |   62 +

 libavcodec/e2k/blockdsp.c            |   72 +

 libavcodec/e2k/dctdsp.h              |   27 +

 libavcodec/e2k/fdctdsp.c             |  389 +++++

 libavcodec/e2k/fft.c                 | 1043 +++++++++++++

 libavcodec/e2k/fft.h                 |   29 +

 libavcodec/e2k/fft_init.c            |  152 ++

 libavcodec/e2k/fmtconvert.c          |   55 +

 libavcodec/e2k/h264chroma.c          |   63 +

 libavcodec/e2k/h264chroma_template.c |  113 ++

 libavcodec/e2k/h264dsp.c             |  820 +++++++++++

 libavcodec/e2k/h264qpel.c            |  255 ++++

 libavcodec/e2k/h264qpel_template.c   |  354 +++++

 libavcodec/e2k/hevcdsp.c             |   94 ++

 libavcodec/e2k/hpeldsp.c             |  302 ++++

 libavcodec/e2k/hpeldsp.h             |   30 +

 libavcodec/e2k/idctdsp.c             |  237 +++

 libavcodec/e2k/lossless_audiodsp.c   |   75 +

 libavcodec/e2k/lossless_videodsp.c   |   59 +

 libavcodec/e2k/mdct15.c              |  187 +++

 libavcodec/e2k/me_cmp.c              |  461 ++++++

 libavcodec/e2k/mpegaudiodsp.c        |  142 ++

 libavcodec/e2k/mpegvideo.c           |  100 ++

 libavcodec/e2k/mpegvideodsp.c        |   86 ++

 libavcodec/e2k/mpegvideoencdsp.c     |   75 +

 libavcodec/e2k/pixblockdsp.c         |   83 ++

 libavcodec/e2k/svq1enc.c             |   68 +

 libavcodec/e2k/vc1dsp.c              |  303 ++++

 libavcodec/e2k/videodsp.c            |   36 +

 libavcodec/e2k/vorbisdsp.c           |   62 +

 libavcodec/e2k/vp3dsp.c              |  169 +++

 libavcodec/e2k/vp8dsp.c              |  428 ++++++

 libavcodec/e2k/vp9dsp.c              | 1740 ++++++++++++++++++++++

 libavcodec/fdctdsp.c                 |    2 +

 libavcodec/fdctdsp.h                 |    2 +

 libavcodec/fft.h                     |    1 +

 libavcodec/fft_template.c            |    1 +

 libavcodec/fmtconvert.c              |    2 +

 libavcodec/fmtconvert.h              |    1 +

 libavcodec/h264chroma.c              |    2 +

 libavcodec/h264chroma.h              |    1 +

 libavcodec/h264dsp.c                 |    1 +

 libavcodec/h264dsp.h                 |    2 +

 libavcodec/h264qpel.c                |    2 +

 libavcodec/h264qpel.h                |    1 +

 libavcodec/hevcdsp.c                 |    2 +

 libavcodec/hevcdsp.h                 |    1 +

 libavcodec/hpeldsp.c                 |    2 +

 libavcodec/hpeldsp.h                 |    1 +

 libavcodec/idctdsp.c                 |    2 +

 libavcodec/idctdsp.h                 |    2 +

 libavcodec/lossless_audiodsp.c       |    2 +

 libavcodec/lossless_audiodsp.h       |    1 +

 libavcodec/lossless_videodsp.c       |    2 +

 libavcodec/lossless_videodsp.h       |    1 +

 libavcodec/mdct15.c                  |    2 +

 libavcodec/mdct15.h                  |    1 +

 libavcodec/me_cmp.c                  |    2 +

 libavcodec/me_cmp.h                  |    1 +

 libavcodec/mpegaudiodsp.c            |    1 +

 libavcodec/mpegaudiodsp.h            |    1 +

 libavcodec/mpegvideo.c               |    2 +

 libavcodec/mpegvideo.h               |    1 +

 libavcodec/mpegvideodsp.c            |    2 +

 libavcodec/mpegvideodsp.h            |    1 +

 libavcodec/mpegvideoencdsp.c         |    2 +

 libavcodec/mpegvideoencdsp.h         |    2 +

 libavcodec/pixblockdsp.c             |    2 +

 libavcodec/pixblockdsp.h             |    2 +

 libavcodec/svq1enc.c                 |    2 +

 libavcodec/svq1enc.h                 |    1 +

 libavcodec/tests/dct.c               |    2 +

 libavcodec/tests/e2k/dct.c           |   31 +

 libavcodec/vc1dsp.c                  |    2 +

 libavcodec/vc1dsp.h                  |    1 +

 libavcodec/videodsp.c                |    2 +

 libavcodec/videodsp.h                |    1 +

 libavcodec/vorbisdsp.c               |    2 +

 libavcodec/vorbisdsp.h               |    1 +

 libavcodec/vp3dsp.c                  |    2 +

 libavcodec/vp3dsp.h                  |    1 +

 libavcodec/vp8dsp.c                  |    2 +

 libavcodec/vp8dsp.h                  |    1 +

 libavcodec/vp9dsp.c                  |    1 +

 libavcodec/vp9dsp.h                  |    1 +

 libavutil/cpu.c                      |    8 +

 libavutil/cpu.h                      |    2 +

 libavutil/cpu_internal.h             |    2 +

 libavutil/e2k/Makefile               |    2 +

 libavutil/e2k/cpu.c                  |   41 +

 libavutil/e2k/cpu.h                  |   27 +

 libavutil/e2k/float_dsp.c            |  188 +++

 libavutil/e2k/intreadwrite.h         |   54 +

 libavutil/e2k/timer.h                |   35 +

 libavutil/e2k/util_e2k.h             |  146 ++

 libavutil/float_dsp.c                |    2 +

 libavutil/float_dsp.h                |    1 +

 libavutil/intreadwrite.h             |    2 +

 libavutil/tests/cpu.c                |    2 +

 libavutil/timer.h                    |    2 +

 libswresample/audioconvert.c         |    1 +

 libswresample/e2k/Makefile           |    1 +

 libswresample/e2k/audio_convert.c    |  110 ++

 libswresample/swresample_internal.h  |    4 +

 libswscale/e2k/Makefile              |    3 +

 libswscale/e2k/swscale.c             | 2046 ++++++++++++++++++++++++++

 libswscale/e2k/yuv2rgb.c             |  248 ++++

 libswscale/e2k/yuv2rgb.h             |   52 +

 libswscale/e2k/yuv2yuv.c             |  146 ++

 libswscale/swscale.c                 |    2 +

 libswscale/swscale_internal.h        |    5 +

 libswscale/swscale_unscaled.c        |    2 +

 libswscale/utils.c                   |   13 +

 libswscale/yuv2rgb.c                 |    2 +

 tests/checkasm/checkasm.c            |    2 +

 tests/checkasm/huffyuvdsp.c          |    8 +-

 122 files changed, 11491 insertions(+), 5 deletions(-)

 create mode 100644 libavcodec/e2k/Makefile

 create mode 100644 libavcodec/e2k/audiodsp.c

 create mode 100644 libavcodec/e2k/blockdsp.c

 create mode 100644 libavcodec/e2k/dctdsp.h

 create mode 100644 libavcodec/e2k/fdctdsp.c

 create mode 100644 libavcodec/e2k/fft.c

 create mode 100644 libavcodec/e2k/fft.h

 create mode 100644 libavcodec/e2k/fft_init.c

 create mode 100644 libavcodec/e2k/fmtconvert.c

 create mode 100644 libavcodec/e2k/h264chroma.c

 create mode 100644 libavcodec/e2k/h264chroma_template.c

 create mode 100644 libavcodec/e2k/h264dsp.c

 create mode 100644 libavcodec/e2k/h264qpel.c

 create mode 100644 libavcodec/e2k/h264qpel_template.c

 create mode 100644 libavcodec/e2k/hevcdsp.c

 create mode 100644 libavcodec/e2k/hpeldsp.c

 create mode 100644 libavcodec/e2k/hpeldsp.h

 create mode 100644 libavcodec/e2k/idctdsp.c

 create mode 100644 libavcodec/e2k/lossless_audiodsp.c

 create mode 100644 libavcodec/e2k/lossless_videodsp.c

 create mode 100644 libavcodec/e2k/mdct15.c

 create mode 100644 libavcodec/e2k/me_cmp.c

 create mode 100644 libavcodec/e2k/mpegaudiodsp.c

 create mode 100644 libavcodec/e2k/mpegvideo.c

 create mode 100644 libavcodec/e2k/mpegvideodsp.c

 create mode 100644 libavcodec/e2k/mpegvideoencdsp.c

 create mode 100644 libavcodec/e2k/pixblockdsp.c

 create mode 100644 libavcodec/e2k/svq1enc.c

 create mode 100644 libavcodec/e2k/vc1dsp.c

 create mode 100644 libavcodec/e2k/videodsp.c

 create mode 100644 libavcodec/e2k/vorbisdsp.c

 create mode 100644 libavcodec/e2k/vp3dsp.c

 create mode 100644 libavcodec/e2k/vp8dsp.c

 create mode 100644 libavcodec/e2k/vp9dsp.c

 create mode 100644 libavcodec/tests/e2k/dct.c

 create mode 100644 libavutil/e2k/Makefile

 create mode 100644 libavutil/e2k/cpu.c

 create mode 100644 libavutil/e2k/cpu.h

 create mode 100644 libavutil/e2k/float_dsp.c

 create mode 100644 libavutil/e2k/intreadwrite.h

 create mode 100644 libavutil/e2k/timer.h

 create mode 100644 libavutil/e2k/util_e2k.h

 create mode 100644 libswresample/e2k/Makefile

 create mode 100644 libswresample/e2k/audio_convert.c

 create mode 100644 libswscale/e2k/Makefile

 create mode 100644 libswscale/e2k/swscale.c

 create mode 100644 libswscale/e2k/yuv2rgb.c

 create mode 100644 libswscale/e2k/yuv2rgb.h

 create mode 100644 libswscale/e2k/yuv2yuv.c

diff --git a/configure b/configure

index 19c1865..3c2a9ab 100755

--- a/configure

+++ b/configure

@@ -1989,6 +1989,7 @@ ARCH_LIST="

     parisc

     ppc

     ppc64

+    e2k

     s390

     sh4

     sparc

@@ -2060,6 +2061,10 @@ ARCH_EXT_LIST_PPC="

     vsx

 "

+ARCH_EXT_LIST_E2K="

+    e2k

+"

+

 ARCH_EXT_LIST_X86="

     $ARCH_EXT_LIST_X86_SIMD

     cpunop

@@ -2069,6 +2074,7 @@ ARCH_EXT_LIST_X86="

 ARCH_EXT_LIST="

     $ARCH_EXT_LIST_ARM

     $ARCH_EXT_LIST_PPC

+    $ARCH_EXT_LIST_E2K

     $ARCH_EXT_LIST_X86

     $ARCH_EXT_LIST_MIPS

     $ARCH_EXT_LIST_LOONGSON

@@ -2594,10 +2600,10 @@ for ext in $(filter_out mmx $ARCH_EXT_LIST_X86_SIMD); do

 done

 aligned_stack_if_any="aarch64 ppc x86"

-fast_64bit_if_any="aarch64 alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"

-fast_clz_if_any="aarch64 alpha avr32 mips ppc x86"

+fast_64bit_if_any="aarch64 alpha ia64 mips64 parisc64 ppc64 e2k sparc64 x86_64"

+fast_clz_if_any="aarch64 alpha avr32 mips ppc e2k x86"

 fast_unaligned_if_any="aarch64 ppc x86"

-simd_align_16_if_any="altivec neon sse"

+simd_align_16_if_any="altivec e2k neon sse"

 simd_align_32_if_any="avx"

 simd_align_64_if_any="avx512"

@@ -4889,6 +4895,9 @@ case "$arch" in

     "Power Macintosh"|ppc*|powerpc*)

         arch="ppc"

     ;;

+    e2k|elbrus)

+        arch="e2k"

+    ;;

     s390|s390x)

         arch="s390"

     ;;

@@ -5177,6 +5186,11 @@ elif enabled ppc; then

         ;;

     esac

+elif enabled e2k; then

+

+    cpu="e2k"

+    cpuflags="-msse4.1 -mno-avx"

+

 elif enabled sparc; then

     case $cpu in

diff --git a/libavcodec/audiodsp.c b/libavcodec/audiodsp.c

index efcb0a8..36b8528 100644

--- a/libavcodec/audiodsp.c

+++ b/libavcodec/audiodsp.c

@@ -113,6 +113,8 @@ av_cold void ff_audiodsp_init(AudioDSPContext *c)

         ff_audiodsp_init_arm(c);

     if (ARCH_PPC)

         ff_audiodsp_init_ppc(c);

+    if (ARCH_E2K)

+        ff_audiodsp_init_e2k(c);

     if (ARCH_X86)

         ff_audiodsp_init_x86(c);

 }

diff --git a/libavcodec/audiodsp.h b/libavcodec/audiodsp.h

index aa6fa78..9c05e28 100644

--- a/libavcodec/audiodsp.h

+++ b/libavcodec/audiodsp.h

@@ -55,6 +55,7 @@ typedef struct AudioDSPContext {

 void ff_audiodsp_init(AudioDSPContext *c);

 void ff_audiodsp_init_arm(AudioDSPContext *c);

 void ff_audiodsp_init_ppc(AudioDSPContext *c);

+void ff_audiodsp_init_e2k(AudioDSPContext *c);

 void ff_audiodsp_init_x86(AudioDSPContext *c);

 #endif /* AVCODEC_AUDIODSP_H */

diff --git a/libavcodec/blockdsp.c b/libavcodec/blockdsp.c

index c7efe7e..704c723 100644

--- a/libavcodec/blockdsp.c

+++ b/libavcodec/blockdsp.c

@@ -71,6 +71,8 @@ av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)

         ff_blockdsp_init_arm(c);

     if (ARCH_PPC)

         ff_blockdsp_init_ppc(c);

+    if (ARCH_E2K)

+        ff_blockdsp_init_e2k(c);

     if (ARCH_X86)

         ff_blockdsp_init_x86(c, avctx);

     if (ARCH_MIPS)

diff --git a/libavcodec/blockdsp.h b/libavcodec/blockdsp.h

index 26fc2ea..8eccb47 100644

--- a/libavcodec/blockdsp.h

+++ b/libavcodec/blockdsp.h

@@ -44,6 +44,7 @@ void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx);

 void ff_blockdsp_init_alpha(BlockDSPContext *c);

 void ff_blockdsp_init_arm(BlockDSPContext *c);

 void ff_blockdsp_init_ppc(BlockDSPContext *c);

+void ff_blockdsp_init_e2k(BlockDSPContext *c);

 void ff_blockdsp_init_x86(BlockDSPContext *c, AVCodecContext *avctx);

 void ff_blockdsp_init_mips(BlockDSPContext *c);

diff --git a/libavcodec/e2k/Makefile b/libavcodec/e2k/Makefile

new file mode 100644

index 0000000..3564b97

--- /dev/null

+++ b/libavcodec/e2k/Makefile

@@ -0,0 +1,31 @@

+# subsystems

+OBJS-$(CONFIG_AUDIODSP)                += e2k/audiodsp.o

+OBJS-$(CONFIG_BLOCKDSP)                += e2k/blockdsp.o

+OBJS-$(CONFIG_FFT)                     += e2k/fft_init.o e2k/fft.o

+OBJS-$(CONFIG_FDCTDSP)                 += e2k/fdctdsp.o

+OBJS-$(CONFIG_FMTCONVERT)              += e2k/fmtconvert.o

+OBJS-$(CONFIG_H264CHROMA)              += e2k/h264chroma.o

+OBJS-$(CONFIG_H264DSP)                 += e2k/h264dsp.o e2k/hpeldsp.o

+OBJS-$(CONFIG_H264QPEL)                += e2k/h264qpel.o

+OBJS-$(CONFIG_HPELDSP)                 += e2k/hpeldsp.o

+OBJS-$(CONFIG_IDCTDSP)                 += e2k/idctdsp.o

+OBJS-$(CONFIG_LLVIDDSP)                += e2k/lossless_videodsp.o

+OBJS-$(CONFIG_MDCT15)                  += e2k/mdct15.o

+OBJS-$(CONFIG_ME_CMP)                  += e2k/me_cmp.o

+OBJS-$(CONFIG_MPEGAUDIODSP)            += e2k/mpegaudiodsp.o

+OBJS-$(CONFIG_MPEGVIDEO)               += e2k/mpegvideo.o e2k/mpegvideodsp.o

+OBJS-$(CONFIG_MPEGVIDEOENC)            += e2k/mpegvideoencdsp.o

+OBJS-$(CONFIG_PIXBLOCKDSP)             += e2k/pixblockdsp.o

+OBJS-$(CONFIG_VC1DSP)                  += e2k/vc1dsp.o

+OBJS-$(CONFIG_VIDEODSP)                += e2k/videodsp.o

+OBJS-$(CONFIG_VP3DSP)                  += e2k/vp3dsp.o

+OBJS-$(CONFIG_VP8DSP)                  += e2k/vp8dsp.o

+

+# decoders/encoders

+OBJS-$(CONFIG_HEVC_DECODER)            += e2k/hevcdsp.o

+OBJS-$(CONFIG_LLAUDDSP)                += e2k/lossless_audiodsp.o

+OBJS-$(CONFIG_SVQ1_ENCODER)            += e2k/svq1enc.o

+OBJS-$(CONFIG_VORBIS_DECODER)          += e2k/vorbisdsp.o

+OBJS-$(CONFIG_VP7_DECODER)             += e2k/vp8dsp.o

+OBJS-$(CONFIG_VP9_DECODER)             += e2k/vp9dsp.o

+

diff --git a/libavcodec/e2k/audiodsp.c b/libavcodec/e2k/audiodsp.c

new file mode 100644

index 0000000..c2e4433

--- /dev/null

+++ b/libavcodec/e2k/audiodsp.c

@@ -0,0 +1,62 @@

+/*

+ * Copyright (C) 2021 Ilya Kurdyukov <jpegqs@gmail.com> for BaseALT, Ltd

+ * Copyright (c) 2007 Luca Barbato <lu_zero@gentoo.org>

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file

+ * miscellaneous audio operations

+ */

+

+#include "config.h"

+

+#include "libavutil/attributes.h"

+#include "libavutil/cpu.h"

+#include "libavutil/e2k/cpu.h"

+#include "libavutil/e2k/util_e2k.h"

+

+#include "libavcodec/audiodsp.h"

+

+static int32_t scalarproduct_int16_e2k(const int16_t *v1, const int16_t *v2, int order)

+{

+    int i;

+    vec_s16 vec1, vec2;

+    vec_s32 res = _mm_setzero_si128(), tmp;

+

+    PRAGMA_E2K("ivdep")

+    for (i = 0; i < order; i += 8) {

+        vec1 = VEC_LD(v1);

+        vec2 = VEC_LD(v2);

+        tmp = _mm_madd_epi16(vec1, vec2);

+        res = _mm_add_epi32(res, tmp);

+        v1 += 8;

+        v2 += 8;

+    }

+

+    res = _mm_hadd_epi32(res, res);

+    return _mm_extract_epi32(res, 0) + _mm_extract_epi32(res, 1);

+}

+

+av_cold void ff_audiodsp_init_e2k(AudioDSPContext *c)

+{

+    if (!E2K_BASE(av_get_cpu_flags()))

+        return;

+

+    c->scalarproduct_int16 = scalarproduct_int16_e2k;

+}

diff --git a/libavcodec/e2k/blockdsp.c b/libavcodec/e2k/blockdsp.c

new file mode 100644

index 0000000..f85dce1

--- /dev/null

+++ b/libavcodec/e2k/blockdsp.c

@@ -0,0 +1,72 @@

+/*

+ * Copyright (C) 2021 Ilya Kurdyukov <jpegqs@gmail.com> for BaseALT, Ltd

+ * Copyright (c) 2002 Brian Foley

+ * Copyright (c) 2002 Dieter Shirley

+ * Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "config.h"

+

+#include <string.h>

+

+#include "libavutil/attributes.h"

+#include "libavutil/cpu.h"

+#include "libavutil/mem.h"

+#include "libavutil/e2k/cpu.h"

+#include "libavutil/e2k/util_e2k.h"

+

+#include "libavcodec/blockdsp.h"

+

+static void clear_block_e2k(int16_t *block)

+{

+    LOAD_ZERO;

+    VEC_ST(block, zerov);

+    VEC_ST(block + 8, zerov);

+    VEC_ST(block + 8 * 2, zerov);

+    VEC_ST(block + 8 * 3, zerov);

+    VEC_ST(block + 8 * 4, zerov);

+    VEC_ST(block + 8 * 5, zerov);

+    VEC_ST(block + 8 * 6, zerov);

+    VEC_ST(block + 8 * 7, zerov);

+}

+

+static void clear_blocks_e2k(int16_t *blocks)

+{

+    int i;

+    LOAD_ZERO;

+    for (i = 0; i < 6; i++, blocks += 64) {

+        VEC_ST(blocks, zerov);

+        VEC_ST(blocks + 8, zerov);

+        VEC_ST(blocks + 8 * 2, zerov);

+        VEC_ST(blocks + 8 * 3, zerov);

+        VEC_ST(blocks + 8 * 4, zerov);

+        VEC_ST(blocks + 8 * 5, zerov);

+        VEC_ST(blocks + 8 * 6, zerov);

+        VEC_ST(blocks + 8 * 7, zerov);

+    }

+}

+

+av_cold void ff_blockdsp_init_e2k(BlockDSPContext *c)

+{

+    if (!E2K_BASE(av_get_cpu_flags()))

+        return;

+

+    c->clear_block = clear_block_e2k;

+    c->clear_blocks = clear_blocks_e2k;

+}

diff --git a/libavcodec/e2k/dctdsp.h b/libavcodec/e2k/dctdsp.h

new file mode 100644

index 0000000..1281dc7

--- /dev/null

+++ b/libavcodec/e2k/dctdsp.h

@@ -0,0 +1,27 @@

+/*

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#ifndef AVCODEC_E2K_DCTDSP_H

+#define AVCODEC_E2K_DCTDSP_H

+

+#include <stdint.h>

+

+void ff_fdct_e2k(int16_t *block);

+void ff_idct_e2k(int16_t *block);

+

+#endif /* AVCODEC_E2K_DCTDSP_H */

diff --git a/libavcodec/e2k/fdctdsp.c b/libavcodec/e2k/fdctdsp.c

new file mode 100644

index 0000000..568a67f

--- /dev/null

+++ b/libavcodec/e2k/fdctdsp.c

@@ -0,0 +1,389 @@

+/*

+ * Copyright (C) 2021 Ilya Kurdyukov <jpegqs@gmail.com> for BaseALT, Ltd

+ * Copyright (C) 2003  James Klicman <james@klicman.org>

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "config.h"

+

+#include "libavutil/attributes.h"

+#include "libavutil/cpu.h"

+#include "libavutil/e2k/cpu.h"

+#include "libavutil/e2k/util_e2k.h"

+

+#include "libavcodec/fdctdsp.h"

+

+#include "dctdsp.h"

+

+#define C1     0.98078528040323044912618224 /* cos(1 * PI / 16) */

+#define C2     0.92387953251128675612818319 /* cos(2 * PI / 16) */

+#define C3     0.83146961230254523707878838 /* cos(3 * PI / 16) */

+#define C4     0.70710678118654752440084436 /* cos(4 * PI / 16) */

+#define C5     0.55557023301960222474283081 /* cos(5 * PI / 16) */

+#define C6     0.38268343236508977172845998 /* cos(6 * PI / 16) */

+#define C7     0.19509032201612826784828487 /* cos(7 * PI / 16) */

+

+#define W0 -(2 * C2)

+#define W1  (2 * C6)

+#define W2 (M_SQRT2 * C6)

+#define W3 (M_SQRT2 * C3)

+#define W4 (M_SQRT2 * (-C1 + C3 + C5 - C7))

+#define W5 (M_SQRT2 *  (C1 + C3 - C5 + C7))

+#define W6 (M_SQRT2 *  (C1 + C3 + C5 - C7))

+#define W7 (M_SQRT2 *  (C1 + C3 - C5 - C7))

+#define W8 (M_SQRT2 *  (C7 - C3))

+#define W9 (M_SQRT2 * (-C1 - C3))

+#define WA (M_SQRT2 * (-C3 - C5))

+#define WB (M_SQRT2 *  (C5 - C3))

+

+#define LD_W0 _mm_set1_ps(W0)

+#define LD_W1 _mm_set1_ps(W1)

+#define LD_W2 _mm_set1_ps(W2)

+#define LD_W3 _mm_set1_ps(W3)

+#define LD_W4 _mm_set1_ps(W4)

+#define LD_W5 _mm_set1_ps(W5)

+#define LD_W6 _mm_set1_ps(W6)

+#define LD_W7 _mm_set1_ps(W7)

+#define LD_W8 _mm_set1_ps(W8)

+#define LD_W9 _mm_set1_ps(W9)

+#define LD_WA _mm_set1_ps(WA)

+#define LD_WB _mm_set1_ps(WB)

+

+#define _mm_madd_ps(a, b, c) _mm_add_ps(_mm_mul_ps(a, b), c)

+

+#define FDCTROW(b0, b1, b2, b3, b4, b5, b6, b7) /* {{{ */           \

+    x0 = _mm_add_ps(b0, b7);            /* x0 = b0 + b7; */         \

+    x7 = _mm_sub_ps(b0, b7);            /* x7 = b0 - b7; */         \

+    x1 = _mm_add_ps(b1, b6);            /* x1 = b1 + b6; */         \

+    x6 = _mm_sub_ps(b1, b6);            /* x6 = b1 - b6; */         \

+    x2 = _mm_add_ps(b2, b5);            /* x2 = b2 + b5; */         \

+    x5 = _mm_sub_ps(b2, b5);            /* x5 = b2 - b5; */         \

+    x3 = _mm_add_ps(b3, b4);            /* x3 = b3 + b4; */         \

+    x4 = _mm_sub_ps(b3, b4);            /* x4 = b3 - b4; */         \

+                                                                    \

+    b7 = _mm_add_ps(x0, x3);            /* b7 = x0 + x3; */         \

+    b1 = _mm_add_ps(x1, x2);            /* b1 = x1 + x2; */         \

+    b0 = _mm_add_ps(b7, b1);            /* b0 = b7 + b1; */         \

+    b4 = _mm_sub_ps(b7, b1);            /* b4 = b7 - b1; */         \

+                                                                    \

+    b2   = _mm_sub_ps(x0, x3);          /* b2 = x0 - x3; */         \

+    b6   = _mm_sub_ps(x1, x2);          /* b6 = x1 - x2; */         \

+    b5   = _mm_add_ps(b6, b2);          /* b5 = b6 + b2; */         \

+    cnst = LD_W2;                                                   \

+    b5   = _mm_mul_ps(cnst, b5);        /* b5 = b5 * W2; */         \

+    cnst = LD_W1;                                                   \

+    b2   = _mm_madd_ps(cnst, b2, b5);   /* b2 = b5 + b2 * W1; */    \

+    cnst = LD_W0;                                                   \

+    b6   = _mm_madd_ps(cnst, b6, b5);   /* b6 = b5 + b6 * W0; */    \

+                                                                    \

+    x0   = _mm_add_ps(x4, x7);          /* x0 = x4 + x7; */         \

+    x1   = _mm_add_ps(x5, x6);          /* x1 = x5 + x6; */         \

+    x2   = _mm_add_ps(x4, x6);          /* x2 = x4 + x6; */         \

+    x3   = _mm_add_ps(x5, x7);          /* x3 = x5 + x7; */         \

+    x8   = _mm_add_ps(x2, x3);          /* x8 = x2 + x3; */         \

+    cnst = LD_W3;                                                   \

+    x8   = _mm_mul_ps(cnst, x8);        /* x8 = x8 * W3; */         \

+                                                                    \

+    cnst = LD_W8;                                                   \

+    x0   = _mm_mul_ps(cnst, x0);        /* x0 *= W8; */             \

+    cnst = LD_W9;                                                   \

+    x1   = _mm_mul_ps(cnst, x1);        /* x1 *= W9; */             \

+    cnst = LD_WA;                                                   \

+    x2   = _mm_madd_ps(cnst, x2, x8);   /* x2 = x2 * WA + x8; */    \

+    cnst = LD_WB;                                                   \

+    x3   = _mm_madd_ps(cnst, x3, x8);   /* x3 = x3 * WB + x8; */    \

+                                                                    \

+    cnst = LD_W4;                                                   \

+    b7   = _mm_madd_ps(cnst, x4, x0);   /* b7 = x4 * W4 + x0; */    \

+    cnst = LD_W5;                                                   \

+    b5   = _mm_madd_ps(cnst, x5, x1);   /* b5 = x5 * W5 + x1; */    \

+    cnst = LD_W6;                                                   \

+    b3   = _mm_madd_ps(cnst, x6, x1);   /* b3 = x6 * W6 + x1; */    \

+    cnst = LD_W7;                                                   \

+    b1   = _mm_madd_ps(cnst, x7, x0);   /* b1 = x7 * W7 + x0; */    \

+                                                                    \

+    b7 = _mm_add_ps(b7, x2);            /* b7 = b7 + x2; */         \

+    b5 = _mm_add_ps(b5, x3);            /* b5 = b5 + x3; */         \

+    b3 = _mm_add_ps(b3, x2);            /* b3 = b3 + x2; */         \

+    b1 = _mm_add_ps(b1, x3)             /* b1 = b1 + x3; */         \

+    /* }}} */

+

+#define FDCTCOL(b0, b1, b2, b3, b4, b5, b6, b7) /* {{{ */           \

+    x0 = _mm_add_ps(b0, b7);            /* x0 = b0 + b7; */         \

+    x7 = _mm_sub_ps(b0, b7);            /* x7 = b0 - b7; */         \

+    x1 = _mm_add_ps(b1, b6);            /* x1 = b1 + b6; */         \

+    x6 = _mm_sub_ps(b1, b6);            /* x6 = b1 - b6; */         \

+    x2 = _mm_add_ps(b2, b5);            /* x2 = b2 + b5; */         \

+    x5 = _mm_sub_ps(b2, b5);            /* x5 = b2 - b5; */         \

+    x3 = _mm_add_ps(b3, b4);            /* x3 = b3 + b4; */         \

+    x4 = _mm_sub_ps(b3, b4);            /* x4 = b3 - b4; */         \

+                                                                    \

+    b7 = _mm_add_ps(x0, x3);            /* b7 = x0 + x3; */         \

+    b1 = _mm_add_ps(x1, x2);            /* b1 = x1 + x2; */         \

+    b0 = _mm_add_ps(b7, b1);            /* b0 = b7 + b1; */         \

+    b4 = _mm_sub_ps(b7, b1);            /* b4 = b7 - b1; */         \

+                                                                    \

+    b2   = _mm_sub_ps(x0, x3);          /* b2 = x0 - x3; */         \

+    b6   = _mm_sub_ps(x1, x2);          /* b6 = x1 - x2; */         \

+    b5   = _mm_add_ps(b6, b2);          /* b5 = b6 + b2; */         \

+    cnst = LD_W2;                                                   \

+    b5   = _mm_mul_ps(cnst, b5);        /* b5 = b5 * W2; */         \

+    cnst = LD_W1;                                                   \

+    b2   = _mm_madd_ps(cnst, b2, b5);   /* b2 = b5 + b2 * W1; */    \

+    cnst = LD_W0;                                                   \

+    b6   = _mm_madd_ps(cnst, b6, b5);   /* b6 = b5 + b6 * W0; */    \

+                                                                    \

+    x0   = _mm_add_ps(x4, x7);          /* x0 = x4 + x7; */         \

+    x1   = _mm_add_ps(x5, x6);          /* x1 = x5 + x6; */         \

+    x2   = _mm_add_ps(x4, x6);          /* x2 = x4 + x6; */         \

+    x3   = _mm_add_ps(x5, x7);          /* x3 = x5 + x7; */         \

+    x8   = _mm_add_ps(x2, x3);          /* x8 = x2 + x3; */         \

+    cnst = LD_W3;                                                   \

+    x8   = _mm_mul_ps(cnst, x8);        /* x8 = x8 * W3; */         \

+                                                                    \

+    cnst = LD_W8;                                                   \

+    x0   = _mm_mul_ps(cnst, x0);        /* x0 *= W8; */             \

+    cnst = LD_W9;                                                   \

+    x1   = _mm_mul_ps(cnst, x1);        /* x1 *= W9; */             \

+    cnst = LD_WA;                                                   \

+    x2   = _mm_madd_ps(cnst, x2, x8);   /* x2 = x2 * WA + x8; */    \

+    cnst = LD_WB;                                                   \

+    x3   = _mm_madd_ps(cnst, x3, x8);   /* x3 = x3 * WB + x8; */    \

+                                                                    \

+    cnst = LD_W4;                                                   \

+    b7   = _mm_madd_ps(cnst, x4, x0);   /* b7 = x4 * W4 + x0; */    \

+    cnst = LD_W5;                                                   \

+    b5   = _mm_madd_ps(cnst, x5, x1);   /* b5 = x5 * W5 + x1; */    \

+    cnst = LD_W6;                                                   \

+    b3   = _mm_madd_ps(cnst, x6, x1);   /* b3 = x6 * W6 + x1; */    \

+    cnst = LD_W7;                                                   \

+    b1   = _mm_madd_ps(cnst, x7, x0);   /* b1 = x7 * W7 + x0; */    \

+                                                                    \

+    b7 = _mm_add_ps(b7, x2);            /* b7 += x2; */             \

+    b5 = _mm_add_ps(b5, x3);            /* b5 += x3; */             \

+    b3 = _mm_add_ps(b3, x2);            /* b3 += x2; */             \

+    b1 = _mm_add_ps(b1, x3)             /* b1 += x3; */             \

+    /* }}} */

+

+/* two dimensional discrete cosine transform */

+void ff_fdct_e2k(int16_t *block)

+{

+    vec_f b00, b10, b20, b30, b40, b50, b60, b70;

+    vec_f b01, b11, b21, b31, b41, b51, b61, b71;

+    vec_f cnst;

+    vec_f x0, x1, x2, x3, x4, x5, x6, x7, x8;

+    vec_s16 a0, a1, a2, a3, a4, a5, a6, a7;

+    vec_s16 z0, z1, z2, z3, z4, z5, z6, z7;

+

+    a0 = VEC_LD(block + 8 * 0);

+    a4 = VEC_LD(block + 8 * 4);

+    a1 = VEC_LD(block + 8 * 1);

+    a5 = VEC_LD(block + 8 * 5);

+    a2 = VEC_LD(block + 8 * 2);

+    a6 = VEC_LD(block + 8 * 6);

+    a3 = VEC_LD(block + 8 * 3);

+    a7 = VEC_LD(block + 8 * 7);

+

+    TRANSPOSE8(a0, a1, a2, a3, a4, a5, a6, a7);

+

+    /* Some of the initial calculations can be done as vector short

+     * before conversion to vec_f.  The following code section

+     * takes advantage of this. */

+

+    /* fdct rows {{{ */

+    z0 = _mm_add_epi16(a0, a7);

+    z7 = _mm_sub_epi16(a0, a7);

+    z1 = _mm_add_epi16(a1, a6);

+    z6 = _mm_sub_epi16(a1, a6);

+    z2 = _mm_add_epi16(a2, a5);

+    z5 = _mm_sub_epi16(a2, a5);

+    z3 = _mm_add_epi16(a3, a4);

+    z4 = _mm_sub_epi16(a3, a4);

+

+#define CTF0(n) \

+    b##n##0 = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(a##n, a##n), 16));\

+    b##n##1 = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpackhi_epi16(a##n, a##n), 16));

+

+    a7 = _mm_add_epi16(z0, z3);

+    a1 = _mm_add_epi16(z1, z2);

+    a0 = _mm_add_epi16(a7, a1);

+    a4 = _mm_sub_epi16(a7, a1);

+    CTF0(0);

+    CTF0(4);

+

+    a2 = _mm_sub_epi16(z0, z3);

+    a6 = _mm_sub_epi16(z1, z2);

+    CTF0(2);

+    CTF0(6);

+

+#undef CTF0

+

+    x0 = _mm_add_ps(b60, b20);

+    x1 = _mm_add_ps(b61, b21);

+

+    cnst = LD_W2;

+    x0   = _mm_mul_ps(cnst, x0);

+    x1   = _mm_mul_ps(cnst, x1);

+    cnst = LD_W1;

+    b20  = _mm_madd_ps(cnst, b20, x0);

+    b21  = _mm_madd_ps(cnst, b21, x1);

+    cnst = LD_W0;

+    b60  = _mm_madd_ps(cnst, b60, x0);

+    b61  = _mm_madd_ps(cnst, b61, x1);

+

+#define CTFX(x, b) \

+    b##0 = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(x, x), 16)); \

+    b##1 = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpackhi_epi16(x, x), 16));

+

+    CTFX(z4, b7);

+    CTFX(z5, b5);

+    CTFX(z6, b3);

+    CTFX(z7, b1);

+

+#undef CTFX

+

+    x0   = _mm_add_ps(b70, b10);

+    x1   = _mm_add_ps(b50, b30);

+    x2   = _mm_add_ps(b70, b30);

+    x3   = _mm_add_ps(b50, b10);

+    x8   = _mm_add_ps(x2, x3);

+    cnst = LD_W3;

+    x8   = _mm_mul_ps(cnst, x8);

+

+    cnst = LD_W8;

+    x0   = _mm_mul_ps(cnst, x0);

+    cnst = LD_W9;

+    x1   = _mm_mul_ps(cnst, x1);

+    cnst = LD_WA;

+    x2   = _mm_madd_ps(cnst, x2, x8);

+    cnst = LD_WB;

+    x3   = _mm_madd_ps(cnst, x3, x8);

+

+    cnst = LD_W4;

+    b70  = _mm_madd_ps(cnst, b70, x0);

+    cnst = LD_W5;

+    b50  = _mm_madd_ps(cnst, b50, x1);

+    cnst = LD_W6;

+    b30  = _mm_madd_ps(cnst, b30, x1);

+    cnst = LD_W7;

+    b10  = _mm_madd_ps(cnst, b10, x0);

+

+    b70 = _mm_add_ps(b70, x2);

+    b50 = _mm_add_ps(b50, x3);

+    b30 = _mm_add_ps(b30, x2);

+    b10 = _mm_add_ps(b10, x3);

+

+    x0   = _mm_add_ps(b71, b11);

+    x1   = _mm_add_ps(b51, b31);

+    x2   = _mm_add_ps(b71, b31);

+    x3   = _mm_add_ps(b51, b11);

+    x8   = _mm_add_ps(x2, x3);

+    cnst = LD_W3;

+    x8   = _mm_mul_ps(cnst, x8);

+

+    cnst = LD_W8;

+    x0   = _mm_mul_ps(cnst, x0);

+    cnst = LD_W9;

+    x1   = _mm_mul_ps(cnst, x1);

+    cnst = LD_WA;

+    x2   = _mm_madd_ps(cnst, x2, x8);

+    cnst = LD_WB;

+    x3   = _mm_madd_ps(cnst, x3, x8);

+

+    cnst = LD_W4;

+    b71  = _mm_madd_ps(cnst, b71, x0);

+    cnst = LD_W5;

+    b51  = _mm_madd_ps(cnst, b51, x1);

+    cnst = LD_W6;

+    b31  = _mm_madd_ps(cnst, b31, x1);

+    cnst = LD_W7;

+    b11  = _mm_madd_ps(cnst, b11, x0);

+

+    b71 = _mm_add_ps(b71, x2);

+    b51 = _mm_add_ps(b51, x3);

+    b31 = _mm_add_ps(b31, x2);

+    b11 = _mm_add_ps(b11, x3);

+    /* }}} */

+

+    /* 8x8 matrix transpose (vec_f[8][2]) {{{ */

+    x0 = _mm_unpacklo_ps(b00, b10);

+    x1 = _mm_unpackhi_ps(b00, b10);

+    x2 = _mm_unpacklo_ps(b20, b30);

+    x3 = _mm_unpackhi_ps(b20, b30);

+    b00 = _mm_unpacklo_ps2(x0, x2);

+    b10 = _mm_unpackhi_ps2(x0, x2);

+    b20 = _mm_unpacklo_ps2(x1, x3);

+    b30 = _mm_unpackhi_ps2(x1, x3);

+

+    x4 = _mm_unpacklo_ps(b41, b51);

+    x5 = _mm_unpackhi_ps(b41, b51);

+    x6 = _mm_unpacklo_ps(b61, b71);

+    x7 = _mm_unpackhi_ps(b61, b71);

+    b41 = _mm_unpacklo_ps2(x4, x6);

+    b51 = _mm_unpackhi_ps2(x4, x6);

+    b61 = _mm_unpacklo_ps2(x5, x7);

+    b71 = _mm_unpackhi_ps2(x5, x7);

+

+    x0 = _mm_unpacklo_ps(b01, b11);

+    x1 = _mm_unpackhi_ps(b01, b11);

+    x2 = _mm_unpacklo_ps(b21, b31);

+    x3 = _mm_unpackhi_ps(b21, b31);

+    x4 = _mm_unpacklo_ps(b40, b50);

+    x5 = _mm_unpackhi_ps(b40, b50);

+    x6 = _mm_unpacklo_ps(b60, b70);

+    x7 = _mm_unpackhi_ps(b60, b70);

+    b40 = _mm_unpacklo_ps2(x0, x2);

+    b50 = _mm_unpackhi_ps2(x0, x2);

+    b60 = _mm_unpacklo_ps2(x1, x3);

+    b70 = _mm_unpackhi_ps2(x1, x3);

+    b01 = _mm_unpacklo_ps2(x4, x6);

+    b11 = _mm_unpackhi_ps2(x4, x6);

+    b21 = _mm_unpacklo_ps2(x5, x7);

+    b31 = _mm_unpackhi_ps2(x5, x7);

+    /* }}} */

+

+    FDCTCOL(b00, b10, b20, b30, b40, b50, b60, b70);

+    FDCTCOL(b01, b11, b21, b31, b41, b51, b61, b71);

+

+    /* round, convert back to short */

+#define CTS(n) \

+    a##n = _mm_packs_epi32(_mm_cvtps_epi32(b##n##0), _mm_cvtps_epi32(b##n##1)); \

+    VEC_ST(block + 8 * n, a##n)

+

+    CTS(0); CTS(1); CTS(2); CTS(3);

+    CTS(4); CTS(5); CTS(6); CTS(7);

+

+#undef CTS

+}

+

+av_cold void ff_fdctdsp_init_e2k(FDCTDSPContext *c, AVCodecContext *avctx,

+                                 unsigned high_bit_depth)

+{

+    if (!E2K_BASE(av_get_cpu_flags()))

+        return;

+

+    // !checkasm

+    // libavcodec/tests/dct

+

+    if (!high_bit_depth) {

+        if (avctx->dct_algo == FF_DCT_AUTO ||

+            avctx->dct_algo == FF_DCT_ALTIVEC) {

+            c->fdct = ff_fdct_e2k;

+        }

+    }

+}

diff --git a/libavcodec/e2k/fft.c b/libavcodec/e2k/fft.c

new file mode 100644

index 0000000..5b58202

--- /dev/null

+++ b/libavcodec/e2k/fft.c

@@ -0,0 +1,1043 @@

+/*

+ * FFT transform

+ * Copyright (C) 2021 Ilya Kurdyukov <jpegqs@gmail.com> for BaseALT, Ltd

+ * Copyright (c) 2014 Rong Yan

+ * Copyright (c) 2009 Loren Merritt

+ *

+ * This algorithm (though not any of the implementation details) is

+ * based on libdjbfft by D. J. Bernstein.

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+

+#include "config.h"

+#include "libavutil/cpu.h"

+#include "libavutil/e2k/util_e2k.h"

+#include "libavcodec/fft.h"

+#include "libavcodec/fft-internal.h"

+#include "fft.h"

+

+#define _mm_madd_ps(a, b, c) _mm_add_ps(_mm_mul_ps(a, b), c)

+#define _mm_msub_ps(a, b, c) _mm_sub_ps(_mm_mul_ps(a, b), c)

+#define _mm_nmsub_ps(a, b, c) _mm_sub_ps(c, _mm_mul_ps(a, b))

+

+static av_always_inline

+void pass_e2k_interleave(FFTComplex *z, const FFTSample *wre, unsigned int n)

+{

+    int i1 = n * 4, i2 = n * 8, i3 = n * 12;

+    FFTSample *out = (FFTSample*)z;

+    const FFTSample *wim = wre + n * 2;

+    vec_f vz0, vzo1, vzo2, vzo3;

+    vec_f x0, x1, x2, x3;

+    vec_f x4, x5, x6, x7;

+    vec_f x8, x9, x10, x11;

+    vec_f x12, x13, x14, x15;

+    vec_f x16, x17, x18, x19;

+    vec_f x20, x21, x22, x23;

+    vec_f vz0plus1, vzo1plus1, vzo2plus1, vzo3plus1;

+    vec_f y0, y1, y2, y3;

+    vec_f y4, y5, y8, y9;

+    vec_f y10, y13, y14, y15;

+    vec_f y16, y17, y18, y19;

+    vec_f y20, y21, y22, y23;

+    vec_f wr1, wi1, wr0, wi0;

+    vec_f wr2, wi2, wr3, wi3;

+    vec_f xmulwi0, xmulwi1, ymulwi2, ymulwi3;

+

+    n = n - 2;

+    vzo2 = _mm_loadu_ps(out + i2);  // zo2.r  zo2.i  z(o2+1).r  z(o2+1).i

+    vzo2plus1 = _mm_loadu_ps(out + i2 + 4);

+    vzo3 = _mm_loadu_ps(out + i3);  // zo3.r  zo3.i  z(o3+1).r  z(o3+1).i

+    vzo3plus1 = _mm_loadu_ps(out + i3 + 4);

+    vz0 = _mm_loadu_ps(out);    // z0.r  z0.i  z1.r  z1.i

+    vz0plus1 = _mm_loadu_ps(out + 4);

+    vzo1 = _mm_loadu_ps(out + i1);  // zo1.r  zo1.i  z(o1+1).r  z(o1+1).i

+    vzo1plus1 = _mm_loadu_ps(out + i1 + 4);

+

+    x0 = _mm_add_ps(vzo2, vzo3);

+    x1 = _mm_sub_ps(vzo2, vzo3);

+    y0 = _mm_add_ps(vzo2plus1, vzo3plus1);

+    y1 = _mm_sub_ps(vzo2plus1, vzo3plus1);

+

+    wr1 = _mm_set1_ps(wre[1]);

+    wi1 = _mm_set1_ps(wim[-1]);

+    wi2 = _mm_set1_ps(wim[-2]);

+    wi3 = _mm_set1_ps(wim[-3]);

+    wr2 = _mm_set1_ps(wre[2]);

+    wr3 = _mm_set1_ps(wre[3]);

+

+    x2 = _mm_unpackhi_ps(x0, x1);

+    x3 = _mm_shuffle_ps(x2, x2, 0x1b);

+

+    y2 = _mm_unpacklo_ps(y0, y1);

+    y3 = _mm_unpackhi_ps(y0, y1);

+    y4 = _mm_shuffle_ps(y2, y2, 0x1b);

+    y5 = _mm_shuffle_ps(y3, y3, 0x1b);

+

+    ymulwi2 = _mm_mul_ps(y4, wi2);

+    ymulwi3 = _mm_mul_ps(y5, wi3);

+    x4 = _mm_mul_ps(x2, wr1);

+    x5 = _mm_mul_ps(x3, wi1);

+    y8 = _mm_madd_ps(y2, wr2, ymulwi2);

+    y9 = _mm_msub_ps(y2, wr2, ymulwi2);

+    x6 = _mm_add_ps(x4, x5);

+    x7 = _mm_sub_ps(x4, x5);

+    y13 = _mm_madd_ps(y3, wr3, ymulwi3);

+    y14 = _mm_msub_ps(y3, wr3, ymulwi3);

+

+    x8 = _mm_shuffle_ps(x6, x7, 0xe4);

+    y10 = _mm_shuffle_ps(y8, y9, 0xe4);

+    y15 = _mm_shuffle_ps(y13, y14, 0xe4);

+

+    x9 = _mm_shuffle_ps(x0, x8, 0x84);

+    x10 = _mm_shuffle_ps(x1, x8, 0x71);

+

+    y16 = _mm_shuffle_ps(y10, y15, 0x88);

+    y17 = _mm_shuffle_ps(y10, y15, 0x77);

+

+    x11 = _mm_add_ps(vz0, x9);

+    x12 = _mm_sub_ps(vz0, x9);

+    x13 = _mm_add_ps(vzo1, x10);

+    x14 = _mm_sub_ps(vzo1, x10);

+

+    y18 = _mm_add_ps(vz0plus1, y16);

+    y19 = _mm_sub_ps(vz0plus1, y16);

+    y20 = _mm_add_ps(vzo1plus1, y17);

+    y21 = _mm_sub_ps(vzo1plus1, y17);

+

+    x15 = _mm_blend_ps(x13, x14, 0xa);

+    x16 = _mm_blend_ps(x14, x13, 0xa);

+    y22 = _mm_blend_ps(y20, y21, 0xa);

+    y23 = _mm_blend_ps(y21, y20, 0xa);

+

+    _mm_storeu_ps(out, x11);

+    _mm_storeu_ps(out + 4, y18);

+    _mm_storeu_ps(out + i1, x15);

+    _mm_storeu_ps(out + i1 + 4, y22);

+    _mm_storeu_ps(out + i2, x12);

+    _mm_storeu_ps(out + i2 + 4, y19);

+    _mm_storeu_ps(out + i3, x16);

+    _mm_storeu_ps(out + i3 + 4, y23);

+

+    do {

+        out += 8;

+        wre += 4;

+        wim -= 4;

+        wr0 = _mm_set1_ps(wre[0]);

+        wr1 = _mm_set1_ps(wre[1]);

+        wi0 = _mm_set1_ps(wim[0]);

+        wi1 = _mm_set1_ps(wim[-1]);

+

+        wr2 = _mm_set1_ps(wre[2]);

+        wr3 = _mm_set1_ps(wre[3]);

+        wi2 = _mm_set1_ps(wim[-2]);

+        wi3 = _mm_set1_ps(wim[-3]);

+

+        vzo2 = _mm_loadu_ps(out + i2);  // zo2.r  zo2.i  z(o2+1).r  z(o2+1).i

+        vzo2plus1 = _mm_loadu_ps(out + i2 + 4);

+        vzo3 = _mm_loadu_ps(out + i3);  // zo3.r  zo3.i  z(o3+1).r  z(o3+1).i

+        vzo3plus1 = _mm_loadu_ps(out + i3 + 4);

+        vz0 = _mm_loadu_ps(out + 0);    // z0.r  z0.i  z1.r  z1.i

+        vz0plus1 = _mm_loadu_ps(out + 4);

+        vzo1 = _mm_loadu_ps(out + i1); // zo1.r  zo1.i  z(o1+1).r  z(o1+1).i

+        vzo1plus1 = _mm_loadu_ps(out + i1 + 4);

+

+        x0 = _mm_add_ps(vzo2, vzo3);

+        x1 = _mm_sub_ps(vzo2, vzo3);

+

+        y0 = _mm_add_ps(vzo2plus1, vzo3plus1);

+        y1 = _mm_sub_ps(vzo2plus1, vzo3plus1);

+

+        x2 = _mm_unpacklo_ps(x0, x1);

+        x3 = _mm_unpackhi_ps(x0, x1);

+        x4 = _mm_shuffle_ps(x2, x2, 0x1b);

+        x5 = _mm_shuffle_ps(x3, x3, 0x1b);

+

+        y2 = _mm_unpacklo_ps(y0, y1);

+        y3 = _mm_unpackhi_ps(y0, y1);

+        y4 = _mm_shuffle_ps(y2, y2, 0x1b);

+        y5 = _mm_shuffle_ps(y3, y3, 0x1b);

+

+        xmulwi0 = _mm_mul_ps(x4, wi0);

+        xmulwi1 = _mm_mul_ps(x5, wi1);

+        x8 = _mm_madd_ps(x2, wr0, xmulwi0);

+        x9 = _mm_msub_ps(x2, wr0, xmulwi0);

+

+        ymulwi2 = _mm_mul_ps(y4, wi2);

+        ymulwi3 = _mm_mul_ps(y5, wi3);

+        x13 = _mm_madd_ps(x3, wr1, xmulwi1);

+        x14 = _mm_msub_ps(x3, wr1, xmulwi1);

+

+        y8 = _mm_madd_ps(y2, wr2, ymulwi2);

+        y9 = _mm_msub_ps(y2, wr2, ymulwi2);

+        y13 = _mm_madd_ps(y3, wr3, ymulwi3);

+        y14 = _mm_msub_ps(y3, wr3, ymulwi3);

+

+        x10 = _mm_shuffle_ps(x8, x9, 0xe4);

+        x15 = _mm_shuffle_ps(x13, x14, 0xe4);

+

+        y10 = _mm_shuffle_ps(y8, y9, 0xe4);

+        y15 = _mm_shuffle_ps(y13, y14, 0xe4);

+

+        x16 = _mm_shuffle_ps(x10, x15, 0x88);

+        x17 = _mm_shuffle_ps(x10, x15, 0x77);

+

+        y16 = _mm_shuffle_ps(y10, y15, 0x88);

+        y17 = _mm_shuffle_ps(y10, y15, 0x77);

+

+        x18 = _mm_add_ps(vz0, x16);

+        x19 = _mm_sub_ps(vz0, x16);

+        x20 = _mm_add_ps(vzo1, x17);

+        x21 = _mm_sub_ps(vzo1, x17);

+

+        y18 = _mm_add_ps(vz0plus1, y16);

+        y19 = _mm_sub_ps(vz0plus1, y16);

+        y20 = _mm_add_ps(vzo1plus1, y17);

+        y21 = _mm_sub_ps(vzo1plus1, y17);

+

+        x22 = _mm_blend_ps(x20, x21, 0xa);

+        x23 = _mm_blend_ps(x21, x20, 0xa);

+        y22 = _mm_blend_ps(y20, y21, 0xa);

+        y23 = _mm_blend_ps(y21, y20, 0xa);

+

+        _mm_storeu_ps(out, x18);

+        _mm_storeu_ps(out + 4, y18);

+        _mm_storeu_ps(out + i1, x22);

+        _mm_storeu_ps(out + i1 + 4, y22);

+        _mm_storeu_ps(out + i2, x19);

+        _mm_storeu_ps(out + i2 + 4, y19);

+        _mm_storeu_ps(out + i3, x23);

+        _mm_storeu_ps(out + i3 + 4, y23);

+    } while (n -= 2);

+}

+

+static av_always_inline

+void fft2_e2k_interleave(FFTComplex *z)

+{

+#if 1

+    vec_f a, b, c;

+    float *out = (float*)z;

+    vec_f sign = _mm_castsi128_ps(_mm_set1_epi32(-1 << 31));

+

+    a = _mm_loadu_ps(out);

+    b = _mm_unpacklo_ps2(a, a);

+    c = _mm_unpackhi_ps2(a, _mm_xor_ps(a, sign));

+    a = _mm_add_ps(b, c);

+    _mm_storeu_ps(out, a);

+#else

+    FFTSample r0, i0, r1, i1;

+    r0 = z[0].re; i0 = z[0].im;

+    r1 = z[1].re; i1 = z[1].im;

+    z[0].re = r0 + r1;

+    z[0].im = i0 + i1;

+    z[1].re = r0 - r1;

+    z[1].im = i0 - i1;

+#endif

+}

+

+static av_always_inline

+void fft4_e2k_interleave(FFTComplex *z)

+{

+    vec_f a, b, c, d;

+    float *out = (float*)z;

+    a = _mm_loadu_ps(out);

+    b = _mm_loadu_ps(out + 4);

+

+    c = _mm_shuffle_ps(a, b, 0x64);

+    d = _mm_shuffle_ps(a, b, 0xce);

+    a = _mm_add_ps(c, d);

+    b = _mm_sub_ps(c, d);

+

+    c = _mm_unpacklo_ps2(a, b);

+    d = _mm_shuffle_ps(a, b, 0xbe);

+

+    a = _mm_add_ps(c, d);

+    b = _mm_sub_ps(c, d);

+    _mm_storeu_ps(out, a);

+    _mm_storeu_ps(out + 4, b);

+}

+

+static av_always_inline

+void fft8_e2k_interleave(FFTComplex *z)

+{

+    vec_f vz0, vz1, vz2, vz3;

+    vec_f x0, x1, x2, x3;

+    vec_f x4, x5, x6, x7;

+    vec_f x8, x9, x10, x11;

+    vec_f x12, x13, x14, x15;

+    vec_f x16, x17, x18, x19;

+    vec_f x20, x21, x22, x23;

+    vec_f x24, x25, x26, x27;

+    vec_f x28, x29, x30, x31;

+    vec_f x32, x33, x34;

+

+    float *out = (float*)z;

+    vec_f vc1 = _mm_set1_ps(sqrthalf);

+

+    vz0 = _mm_loadu_ps(out);

+    vz1 = _mm_loadu_ps(out + 4);

+    vz2 = _mm_loadu_ps(out + 8);

+    vz3 = _mm_loadu_ps(out + 12);

+

+    x0 = _mm_shuffle_ps(vz0, vz1, 0x64);

+    x1 = _mm_shuffle_ps(vz0, vz1, 0xce);

+    x2 = _mm_shuffle_ps(vz2, vz3, 0x46);

+    x3 = _mm_shuffle_ps(vz2, vz3, 0xec);

+

+    x4 = _mm_add_ps(x0, x1);

+    x5 = _mm_sub_ps(x0, x1);

+    x6 = _mm_add_ps(x2, x3);

+    x7 = _mm_sub_ps(x2, x3);

+

+    x8 = _mm_unpacklo_ps2(x4, x5);

+    x9 = _mm_shuffle_ps(x4, x5, 0xbe);

+    x10 = _mm_shuffle_ps(x6, x7, 0x66);

+    x11 = _mm_shuffle_ps(x6, x7, 0xcc);

+

+    x12 = _mm_add_ps(x8, x9);

+    x13 = _mm_sub_ps(x8, x9);

+    x14 = _mm_add_ps(x10, x11);

+    x15 = _mm_sub_ps(x10, x11);

+    x16 = _mm_unpacklo_ps(x12, x13);

+    x17 = _mm_unpacklo_ps(x14, x15);

+    x18 = _mm_shuffle_ps(x17, x17, 0x6c);

+    x19 = _mm_add_ps(x16, x18); // z0.r  z2.r  z0.i  z2.i

+    x20 = _mm_sub_ps(x16, x18); // z4.r  z6.r  z4.i  z6.i

+

+    x21 = _mm_unpackhi_ps(x12, x13);

+    x22 = _mm_unpackhi_ps(x14, x15);

+    x23 = _mm_unpackhi_ps2(x22, x22);

+    x24 = _mm_add_ps(x22, x23);

+    x25 = _mm_sub_ps(x22, x23);

+

+    x26 = _mm_unpacklo_ps2(x24, x25);

+    x26 = _mm_mul_ps(_mm_shuffle_ps(x26, x26, 0x8d), vc1); // 1,s1,0,s0

+

+    x27 = _mm_add_ps(x21, x26); // z1.r  z7.r  z1.i  z3.i

+    x28 = _mm_sub_ps(x21, x26); // z5.r  z3.r  z5.i  z7.i

+

+    x29 = _mm_shuffle_ps(x19, x27, 0x88); // z0.r  z0.i  z1.r  z1.i

+    x30 = _mm_shuffle_ps(x19, x27, 0xdd); // z2.r  z2.i  z7.r  z3.i

+    x31 = _mm_shuffle_ps(x20, x28, 0x88); // z4.r  z4.i  z5.r  z5.i

+    x32 = _mm_shuffle_ps(x20, x28, 0xdd); // z6.r  z6.i  z3.r  z7.i

+    x33 = _mm_blend_ps(x30, x32, 0x4); // z2.r  z2.i  z3.r  z3.i

+    x34 = _mm_blend_ps(x32, x30, 0x4); // z6.r  z6.i  z7.r  z7.i

+

+    _mm_storeu_ps(out, x29);

+    _mm_storeu_ps(out + 4, x33);

+    _mm_storeu_ps(out + 8, x31);

+    _mm_storeu_ps(out + 12, x34);

+}

+

+static av_always_inline

+void fft16_e2k_interleave(FFTComplex *z)

+{

+    float *out = (float*)z;

+    vec_f vc0 = _mm_set1_ps(sqrthalf);

+    vec_f vc1 = _mm_set1_ps(ff_cos_16[1]);

+    vec_f vc2 = _mm_set1_ps(ff_cos_16[3]);

+    vec_f vz0, vz1, vz2, vz3;

+    vec_f vz4, vz5, vz6, vz7;

+    vec_f x0, x1, x2, x3;

+    vec_f x4, x5, x6, x7;

+    vec_f x8, x9, x10, x11;

+    vec_f x12, x13, x14, x15;

+    vec_f x16, x17, x18, x19;

+    vec_f x20, x21, x22, x23;

+    vec_f x24, x25, x26, x27;

+    vec_f x28, x29, x30, x31;

+    vec_f x32, x33, x34, x35;

+    vec_f x36, x37, x38, x39;

+    vec_f x40, x41, x42, x43;

+    vec_f x44, x45, x46, x47;

+    vec_f x48, x49, x50, x51;

+    vec_f x52, x53, x54, x55;

+    vec_f x56, x57, x58, x59;

+    vec_f x60, x61, x62, x63;

+    vec_f x64, x65, x66, x67;

+    vec_f x68, x69, x70, x71;

+    vec_f x72, x73, x74, x75;

+    vec_f x76, x77, x78, x79;

+    vec_f x80, x81, x82, x83;

+    vec_f x84, x85, x86;

+

+    vz0 = _mm_loadu_ps(out);

+    vz1 = _mm_loadu_ps(out + 4);

+    vz2 = _mm_loadu_ps(out + 8);

+    vz3 = _mm_loadu_ps(out + 12);

+    vz4 = _mm_loadu_ps(out + 16);

+    vz5 = _mm_loadu_ps(out + 20);

+    vz6 = _mm_loadu_ps(out + 24);

+    vz7 = _mm_loadu_ps(out + 28);

+

+    x0 = _mm_shuffle_ps(vz0, vz1, 0x64);

+    x1 = _mm_shuffle_ps(vz0, vz1, 0xce);

+    x2 = _mm_unpacklo_ps2(vz2, vz3);

+    x3 = _mm_unpackhi_ps2(vz2, vz3);

+

+    x4 = _mm_shuffle_ps(vz4, vz5, 0x64);

+    x5 = _mm_shuffle_ps(vz4, vz5, 0xce);

+    x6 = _mm_shuffle_ps(vz6, vz7, 0x64);

+    x7 = _mm_shuffle_ps(vz6, vz7, 0xce);

+

+    x8 = _mm_add_ps(x0, x1);

+    x9 = _mm_sub_ps(x0, x1);

+    x10 = _mm_add_ps(x2, x3);

+    x11 = _mm_sub_ps(x2, x3);

+

+    x12 = _mm_add_ps(x4, x5);

+    x13 = _mm_sub_ps(x4, x5);

+    x14 = _mm_add_ps(x6, x7);

+    x15 = _mm_sub_ps(x6, x7);

+

+    x16 = _mm_unpacklo_ps2(x8, x9);

+    x17 = _mm_shuffle_ps(x8, x9, 0xbe);

+    x18 = _mm_shuffle_ps(x10, x11, 0x96);

+    x19 = _mm_shuffle_ps(x10, x11, 0xcc);

+    x20 = _mm_unpacklo_ps2(x12, x14);

+    x21 = _mm_unpackhi_ps2(x12, x14);

+    x22 = _mm_unpacklo_ps2(x13, x15);

+    x23 = _mm_shuffle_ps(x13, x15, 0xbb);

+

+    x24 = _mm_add_ps(x16, x17);

+    x25 = _mm_sub_ps(x16, x17);

+    x26 = _mm_add_ps(x18, x19);

+    x27 = _mm_sub_ps(x18, x19);

+    x28 = _mm_add_ps(x20, x21);

+    x29 = _mm_sub_ps(x20, x21);

+    x30 = _mm_add_ps(x22, x23);

+    x31 = _mm_sub_ps(x22, x23);

+

+    x32 = _mm_add_ps(x24, x26);

+    x33 = _mm_sub_ps(x24, x26);

+    x34 = _mm_unpacklo_ps2(x32, x33);

+

+    x35 = _mm_shuffle_ps(x28, x29, 0x96);

+    x36 = _mm_shuffle_ps(x28, x29, 0xcc);

+    x37 = _mm_add_ps(x35, x36);

+    x38 = _mm_sub_ps(x35, x36);

+    x39 = _mm_shuffle_ps(x37, x38, 0x14);

+

+    x40 = _mm_shuffle_ps(x27, x38, 0xeb);

+    x41 = _mm_shuffle_ps(x26, x37, 0xbe);

+    x42 = _mm_add_ps(x40, x41);

+    x43 = _mm_sub_ps(x40, x41);

+    x44 = _mm_mul_ps(x42, vc0);

+    x45 = _mm_mul_ps(x43, vc0);

+

+    x46 = _mm_add_ps(x34, x39);  // z0.r  z0.i  z4.r  z4.i

+    x47 = _mm_sub_ps(x34, x39);  // z8.r  z8.i  z12.r  z12.i

+

+    x48 = _mm_shuffle_ps(x30, x31, 0x96);

+    x49 = _mm_shuffle_ps(x30, x31, 0x3c);

+    x50 = _mm_add_ps(x48, x49);

+    x51 = _mm_sub_ps(x48, x49);

+    x52 = _mm_mul_ps(x50, vc1);

+    x53 = _mm_mul_ps(x50, vc2);

+    x54 = _mm_mul_ps(x51, vc1);

+    x55 = _mm_mul_ps(x51, vc2);

+

+    x56 = _mm_unpackhi_ps2(x24, x25);

+    x57 = _mm_shuffle_ps(x44, x45, 0x14);

+    x58 = _mm_add_ps(x56, x57);

+    x59 = _mm_sub_ps(x56, x57);

+

+    x60 = _mm_shuffle_ps(x54, x54, 0xb1);

+    x61 = _mm_shuffle_ps(x55, x55, 0xb1);

+    x62 = _mm_add_ps(x52, x61);

+    x63 = _mm_sub_ps(x52, x61);

+    x64 = _mm_add_ps(x60, x53);

+    x65 = _mm_sub_ps(x60, x53);

+    x66 = _mm_shuffle_ps(x62, x64, 0xb4);

+    x67 = _mm_shuffle_ps(x65, x63, 0xb4);

+

+    x68 = _mm_add_ps(x58, x66); // z1.r    z1.i  z3.r    z3.i

+    x69 = _mm_sub_ps(x58, x66); // z9.r    z9.i  z11.r  z11.i

+    x70 = _mm_add_ps(x59, x67); // z5.r    z5.i  z15.r  z15.i

+    x71 = _mm_sub_ps(x59, x67); // z13.r  z13.i z7.r   z7.i

+

+    x72 = _mm_shuffle_ps(x27, x27, 0xe1);

+    x73 = _mm_add_ps(x25, x72);

+    x74 = _mm_sub_ps(x25, x72);

+    x75 = _mm_unpacklo_ps2(x73, x74);

+    x76 = _mm_shuffle_ps(x44, x45, 0xeb);

+    x77 = _mm_add_ps(x75, x76); // z2.r   z2.i    z6.r    z6.i

+    x78 = _mm_sub_ps(x75, x76); // z10.r  z10.i  z14.r  z14.i

+

+    x79 = _mm_unpacklo_ps2(x46, x68); // z0.r  z0.i  z1.r  z1.i

+    x80 = _mm_shuffle_ps(x77, x68, 0xe4); // z2.r  z2.i  z3.r  z3.i

+    x81 = _mm_shuffle_ps(x46, x70, 0x4e); // z4.r  z4.i  z5.r  z5.i

+    x82 = _mm_unpackhi_ps2(x77, x71); // z6.r  z6.i  z7.r  z7.i

+    _mm_storeu_ps(out, x79);

+    _mm_storeu_ps(out + 4, x80);

+    _mm_storeu_ps(out + 8, x81);

+    _mm_storeu_ps(out + 12, x82);

+    x83 = _mm_unpacklo_ps2(x47, x69); // z8.r  z8.i  z9.r  z9.i

+    x84 = _mm_shuffle_ps(x78, x69, 0xe4); // z10.r  z10.i  z11.r  z11.i

+    x85 = _mm_shuffle_ps(x47, x71, 0x4e); // z12.r  z12.i  z13.r  z13.i

+    x86 = _mm_unpackhi_ps2(x78, x70); // z14.r  z14.i  z15.r  z15.i

+    _mm_storeu_ps(out + 16, x83);

+    _mm_storeu_ps(out + 20, x84);

+    _mm_storeu_ps(out + 24, x85);

+    _mm_storeu_ps(out + 28, x86);

+}

+

+static av_always_inline

+void fft4_e2k(FFTComplex *z)

+{

+    vec_f a, b, c, d;

+    float *out = (float*)z;

+    a = _mm_loadu_ps(out);

+    b = _mm_loadu_ps(out + 4);

+

+    c = _mm_shuffle_ps(a, b, 0x64);

+    d = _mm_shuffle_ps(a, b, 0xce);

+    a = _mm_add_ps(c, d);

+    b = _mm_sub_ps(c, d);

+

+    c = _mm_unpacklo_ps(a, b);

+    d = _mm_unpackhi_ps(a, _mm_shuffle_ps(b, b, 0xb1));

+

+    a = _mm_add_ps(c, d);

+    b = _mm_sub_ps(c, d);

+

+    c = _mm_unpacklo_ps2(a, b);

+    d = _mm_unpackhi_ps2(a, b);

+

+    _mm_storeu_ps(out, c);

+    _mm_storeu_ps(out + 4, d);

+}

+

+static av_always_inline

+void fft8_e2k(FFTComplex *z)

+{

+    vec_f vz0, vz1, vz2, vz3;

+    vec_f vz4, vz5, vz6, vz7, vz8;

+

+    float *out = (float*)z;

+    vec_f vc0 = _mm_setzero_ps();

+    vec_f vc1 = _mm_setr_ps(-sqrthalf, sqrthalf, sqrthalf, -sqrthalf);

+    vec_f vc2 = _mm_set1_ps(sqrthalf);

+

+    vz0 = _mm_loadu_ps(out);

+    vz1 = _mm_loadu_ps(out + 4);

+    vz2 = _mm_loadu_ps(out + 8);

+    vz3 = _mm_loadu_ps(out + 12);

+

+    vz6 = _mm_unpacklo_ps(vz2, vz3);

+    vz7 = _mm_unpackhi_ps(vz2, vz3);

+    vz4 = _mm_shuffle_ps(vz0, vz1, 0x64);

+    vz5 = _mm_shuffle_ps(vz0, vz1, 0xce);

+

+    vz2 = _mm_add_ps(vz6, vz7);

+    vz3 = _mm_sub_ps(vz6, vz7);

+    vz8 = _mm_shuffle_ps(vz3, vz3, 0x4e);

+

+    vz0 = _mm_add_ps(vz4, vz5);

+    vz1 = _mm_sub_ps(vz4, vz5);

+

+    vz3 = _mm_madd_ps(vz3, vc1, vc0);

+    vz3 = _mm_madd_ps(vz8, vc2, vz3);

+

+    vz4 = _mm_unpacklo_ps(vz0, vz1);

+    vz5 = _mm_unpackhi_ps(vz0, _mm_shuffle_ps(vz1, vz1, 0xb1));

+    vz6 = _mm_shuffle_ps(vz2, vz3, 0x39);

+    vz7 = _mm_shuffle_ps(vz2, vz3, 0x6c);

+

+    vz0 = _mm_add_ps(vz4, vz5);

+    vz1 = _mm_sub_ps(vz4, vz5);

+    vz2 = _mm_add_ps(vz6, vz7);

+    vz3 = _mm_sub_ps(vz6, vz7);

+

+    vz4 = _mm_unpacklo_ps2(vz0, vz1);

+    vz5 = _mm_unpackhi_ps2(vz0, vz1);

+    vz6 = _mm_shuffle_ps(vz2, vz3, 0xd8);

+    vz7 = _mm_shuffle_ps(vz2, vz3, 0x8d);

+

+    vz2 = _mm_sub_ps(vz4, vz6);

+    vz3 = _mm_sub_ps(vz5, vz7);

+

+    vz0 = _mm_add_ps(vz4, vz6);

+    vz1 = _mm_add_ps(vz5, vz7);

+

+    _mm_storeu_ps(out, vz0);

+    _mm_storeu_ps(out + 4, vz1);

+    _mm_storeu_ps(out + 8, vz2);

+    _mm_storeu_ps(out + 12, vz3);

+}

+

+static av_always_inline

+void fft16_e2k(FFTComplex *z)

+{

+    float *out = (float*)z;

+    vec_f vc0 = _mm_setzero_ps();

+    vec_f vc1 = _mm_setr_ps(-sqrthalf, sqrthalf, sqrthalf, -sqrthalf);

+    vec_f vc2 = _mm_set1_ps(sqrthalf);

+    vec_f vc3 = _mm_setr_ps(1.0, 0.92387953, sqrthalf, 0.38268343);

+    vec_f vc4 = _mm_setr_ps(0.0, 0.38268343, sqrthalf, 0.92387953);

+    vec_f vc5 = _mm_setr_ps(-0.0, -0.38268343, -sqrthalf, -0.92387953);

+

+    vec_f vz0, vz1, vz2, vz3;

+    vec_f vz4, vz5, vz6, vz7;

+    vec_f vz8, vz9, vz10, vz11;

+    vec_f vz12, vz13;

+

+    vz0 = _mm_loadu_ps(out + 16);

+    vz1 = _mm_loadu_ps(out + 20);

+    vz2 = _mm_loadu_ps(out + 24);

+    vz3 = _mm_loadu_ps(out + 28);

+

+    vz4 = _mm_shuffle_ps(vz0, vz1, 0x64);

+    vz5 = _mm_shuffle_ps(vz0, vz1, 0xce);

+    vz6 = _mm_shuffle_ps(vz2, vz3, 0x64);

+    vz7 = _mm_shuffle_ps(vz2, vz3, 0xce);

+

+    vz0 = _mm_add_ps(vz4, vz5);

+    vz1= _mm_sub_ps(vz4, vz5);

+    vz2 = _mm_add_ps(vz6, vz7);

+    vz3 = _mm_sub_ps(vz6, vz7);

+

+    vz4 = _mm_unpacklo_ps(vz0, vz1);

+    vz5 = _mm_unpackhi_ps(vz0, _mm_shuffle_ps(vz1, vz1, 0xb1));

+    vz6 = _mm_unpacklo_ps(vz2, vz3);

+    vz7 = _mm_unpackhi_ps(vz2, _mm_shuffle_ps(vz3, vz3, 0xb1));

+

+    vz0 = _mm_add_ps(vz4, vz5);

+    vz1 = _mm_sub_ps(vz4, vz5);

+    vz2 = _mm_add_ps(vz6, vz7);

+    vz3 = _mm_sub_ps(vz6, vz7);

+

+    vz4 = _mm_unpacklo_ps2(vz0, vz1);

+    vz5 = _mm_unpackhi_ps2(vz0, vz1);

+

+    vz6 = _mm_unpacklo_ps2(vz2, vz3);

+    vz7 = _mm_unpackhi_ps2(vz2, vz3);

+

+    vz0 = _mm_loadu_ps(out);

+    vz1 = _mm_loadu_ps(out + 4);

+    vz2 = _mm_loadu_ps(out + 8);

+    vz3 = _mm_loadu_ps(out + 12);

+    vz10 = _mm_unpacklo_ps(vz2, vz3);

+    vz11 = _mm_unpackhi_ps(vz2, vz3);

+    vz8 = _mm_shuffle_ps(vz0, vz1, 0x64);

+    vz9 = _mm_shuffle_ps(vz0, vz1, 0xce);

+

+    vz2 = _mm_add_ps(vz10, vz11);

+    vz3 = _mm_sub_ps(vz10, vz11);

+    vz12 = _mm_shuffle_ps(vz3, vz3, 0x4e);

+    vz0 = _mm_add_ps(vz8, vz9);

+    vz1 = _mm_sub_ps(vz8, vz9);

+

+    vz3 = _mm_madd_ps(vz3, vc1, vc0);

+    vz3 = _mm_madd_ps(vz12, vc2, vz3);

+    vz8 = _mm_unpacklo_ps(vz0, vz1);

+    vz9 = _mm_unpackhi_ps(vz0, _mm_shuffle_ps(vz1, vz1, 0xb1));

+    vz10 = _mm_shuffle_ps(vz2, vz3, 0x39);

+    vz11 = _mm_shuffle_ps(vz2, vz3, 0x6c);

+

+    vz0 = _mm_add_ps(vz8, vz9);

+    vz1 = _mm_sub_ps(vz8, vz9);

+    vz2 = _mm_add_ps(vz10, vz11);

+    vz3 = _mm_sub_ps(vz10, vz11);

+

+    vz8 = _mm_unpacklo_ps2(vz0, vz1);

+    vz9 = _mm_unpackhi_ps2(vz0, vz1);

+    vz10 = _mm_shuffle_ps(vz2, vz3, 0xd8);

+    vz11 = _mm_shuffle_ps(vz2, vz3, 0x8d);

+

+    vz2 = _mm_sub_ps(vz8, vz10);

+    vz3 = _mm_sub_ps(vz9, vz11);

+    vz0 = _mm_add_ps(vz8, vz10);

+    vz1 = _mm_add_ps(vz9, vz11);

+

+    vz8 = _mm_madd_ps(vz4, vc3, vc0);

+    vz9 = _mm_madd_ps(vz5, vc3, vc0);

+    vz10 = _mm_madd_ps(vz6, vc3, vc0);

+    vz11 = _mm_madd_ps(vz7, vc3, vc0);

+

+    vz8 = _mm_madd_ps(vz5, vc4, vz8);

+    vz9 = _mm_madd_ps(vz4, vc5, vz9);

+    vz10 = _mm_madd_ps(vz7, vc5, vz10);

+    vz11 = _mm_madd_ps(vz6, vc4, vz11);

+

+    vz12 = _mm_sub_ps(vz10, vz8);

+    vz10 = _mm_add_ps(vz10, vz8);

+

+    vz13 = _mm_sub_ps(vz9, vz11);

+    vz11 = _mm_add_ps(vz9, vz11);

+

+    vz4 = _mm_sub_ps(vz0, vz10);

+    vz0 = _mm_add_ps(vz0, vz10);

+

+    vz7 = _mm_sub_ps(vz3, vz12);

+    vz3 = _mm_add_ps(vz3, vz12);

+

+    vz5 = _mm_sub_ps(vz1, vz11);

+    vz1 = _mm_add_ps(vz1, vz11);

+

+    vz6 = _mm_sub_ps(vz2, vz13);

+    vz2 = _mm_add_ps(vz2, vz13);

+

+    _mm_storeu_ps(out, vz0);

+    _mm_storeu_ps(out + 4, vz1);

+    _mm_storeu_ps(out + 8, vz2);

+    _mm_storeu_ps(out + 12, vz3);

+    _mm_storeu_ps(out + 16, vz4);

+    _mm_storeu_ps(out + 20, vz5);

+    _mm_storeu_ps(out + 24, vz6);

+    _mm_storeu_ps(out + 28, vz7);

+}

+

+static av_always_inline

+void pass_e2k(FFTComplex *z, const FFTSample *wre, unsigned int n)

+{

+    int i1 = n * 4, i2 = n * 8, i3 = n * 12;

+    FFTSample *out = (FFTSample*)z;

+    const FFTSample *wim = wre + n * 2;

+    vec_f v0, v1, v2, v3;

+    vec_f v4, v5, v6, v7;

+    vec_f v8, v9, v10, v11;

+    vec_f v12, v13;

+

+    n = n - 2;

+

+    v8 = _mm_loadu_ps(wre);

+#if 0

+    v9 = _mm_loadu_ps(wim - 3);

+#else

+    v10 = _mm_loadu_ps(wim);

+    v9 = _mm_loadu_ps(wim - 4);

+    v9 = _mm_castsi128_ps(_mm_alignr_epi8(_mm_castps_si128(v10), _mm_castps_si128(v9), 4));

+#endif

+    v9 = _mm_shuffle_ps(v9, v9, 0x1b);

+

+    v4 = _mm_loadu_ps(out + i2);

+    v5 = _mm_loadu_ps(out + i2 + 4);

+    v6 = _mm_loadu_ps(out + i3);

+    v7 = _mm_loadu_ps(out + i3 + 4);

+    v10 = _mm_mul_ps(v4, v8); // r2*wre

+    v11 = _mm_mul_ps(v5, v8); // i2*wre

+    v12 = _mm_mul_ps(v6, v8); // r3*wre

+    v13 = _mm_mul_ps(v7, v8); // i3*wre

+

+    v0 = _mm_loadu_ps(out); // r0

+    v3 = _mm_loadu_ps(out + i1 + 4); // i1

+    v10 = _mm_madd_ps(v5, v9, v10); // r2*wim

+    v11 = _mm_nmsub_ps(v4, v9, v11); // i2*wim

+    v12 = _mm_nmsub_ps(v7, v9, v12); // r3*wim

+    v13 = _mm_madd_ps(v6, v9, v13); // i3*wim

+

+    v1 = _mm_loadu_ps(out + 4); // i0

+    v2 = _mm_loadu_ps(out + i1); // r1

+    v8 = _mm_sub_ps(v12, v10);

+    v12 = _mm_add_ps(v12, v10);

+    v9 = _mm_sub_ps(v11, v13);

+    v13 = _mm_add_ps(v11, v13);

+    v4 = _mm_sub_ps(v0, v12);

+    v0 = _mm_add_ps(v0, v12);

+    v7 = _mm_sub_ps(v3, v8);

+    v3 = _mm_add_ps(v3, v8);

+

+    _mm_storeu_ps(out, v0); // r0

+    _mm_storeu_ps(out + i1 + 4, v3); // i1

+    _mm_storeu_ps(out + i2, v4); // r2

+    _mm_storeu_ps(out + i3 + 4, v7);// i3

+

+    v5 = _mm_sub_ps(v1, v13);

+    v1 = _mm_add_ps(v1, v13);

+    v6 = _mm_sub_ps(v2, v9);

+    v2 = _mm_add_ps(v2, v9);

+

+    _mm_storeu_ps(out + 4, v1); // i0

+    _mm_storeu_ps(out + i1, v2); // r1

+    _mm_storeu_ps(out + i2 + 4, v5); // i2

+    _mm_storeu_ps(out + i3, v6); // r3

+

+    do {

+        out += 8;

+        wre += 4;

+        wim -= 4;

+

+        v8 = _mm_loadu_ps(wre);

+#if 0

+        v9 = _mm_loadu_ps(wim - 3);

+#else

+        v10 = _mm_loadu_ps(wim);

+        v9 = _mm_loadu_ps(wim - 4);

+        v9 = _mm_castsi128_ps(_mm_alignr_epi8(_mm_castps_si128(v10), _mm_castps_si128(v9), 4));

+#endif

+        v9 = _mm_shuffle_ps(v9, v9, 0x1b);

+

+        v4 = _mm_loadu_ps(out + i2); // r2

+        v5 = _mm_loadu_ps(out + i2 + 4); // i2

+        v6 = _mm_loadu_ps(out + i3); // r3

+        v7 = _mm_loadu_ps(out + i3 + 4);// i3

+        v10 = _mm_mul_ps(v4, v8); // r2*wre

+        v11 = _mm_mul_ps(v5, v8); // i2*wre

+        v12 = _mm_mul_ps(v6, v8); // r3*wre

+        v13 = _mm_mul_ps(v7, v8); // i3*wre

+

+        v0 = _mm_loadu_ps(out); // r0

+        v3 = _mm_loadu_ps(out + i1 + 4); // i1

+        v10 = _mm_madd_ps(v5, v9, v10); // r2*wim

+        v11 = _mm_nmsub_ps(v4, v9, v11); // i2*wim

+        v12 = _mm_nmsub_ps(v7, v9, v12); // r3*wim

+        v13 = _mm_madd_ps(v6, v9, v13); // i3*wim

+

+        v1 = _mm_loadu_ps(out + 4); // i0

+        v2 = _mm_loadu_ps(out + i1); // r1

+        v8 = _mm_sub_ps(v12, v10);

+        v12 = _mm_add_ps(v12, v10);

+        v9 = _mm_sub_ps(v11, v13);

+        v13 = _mm_add_ps(v11, v13);

+        v4 = _mm_sub_ps(v0, v12);

+        v0 = _mm_add_ps(v0, v12);

+        v7 = _mm_sub_ps(v3, v8);

+        v3 = _mm_add_ps(v3, v8);

+

+        _mm_storeu_ps(out, v0); // r0

+        _mm_storeu_ps(out + i1 + 4, v3); // i1

+        _mm_storeu_ps(out + i2, v4); // r2

+        _mm_storeu_ps(out + i3 + 4, v7); // i3

+

+        v5 = _mm_sub_ps(v1, v13);

+        v1 = _mm_add_ps(v1, v13);

+        v6 = _mm_sub_ps(v2, v9);

+        v2 = _mm_add_ps(v2, v9);

+

+        _mm_storeu_ps(out + 4, v1); // i0

+        _mm_storeu_ps(out + i1, v2); // r1

+        _mm_storeu_ps(out + i2 + 4, v5); // i2

+        _mm_storeu_ps(out + i3, v6); // r3

+    } while (n -= 2);

+}

+

+static void fft32_e2k_interleave(FFTComplex *z)

+{

+    fft16_e2k_interleave(z);

+    fft8_e2k_interleave(z+16);

+    fft8_e2k_interleave(z+24);

+    pass_e2k_interleave(z,ff_cos_32,4);

+}

+

+static void fft64_e2k_interleave(FFTComplex *z)

+{

+    fft32_e2k_interleave(z);

+    fft16_e2k_interleave(z+32);

+    fft16_e2k_interleave(z+48);

+    pass_e2k_interleave(z,ff_cos_64, 8);

+}

+

+static void fft128_e2k_interleave(FFTComplex *z)

+{

+    fft64_e2k_interleave(z);

+    fft32_e2k_interleave(z+64);

+    fft32_e2k_interleave(z+96);

+    pass_e2k_interleave(z,ff_cos_128,16);

+}

+

+static void fft256_e2k_interleave(FFTComplex *z)

+{

+    fft128_e2k_interleave(z);

+    fft64_e2k_interleave(z+128);

+    fft64_e2k_interleave(z+192);

+    pass_e2k_interleave(z,ff_cos_256,32);

+}

+

+static void fft512_e2k_interleave(FFTComplex *z)

+{

+    fft256_e2k_interleave(z);

+    fft128_e2k_interleave(z+256);

+    fft128_e2k_interleave(z+384);

+    pass_e2k_interleave(z,ff_cos_512,64);

+}

+

+static void fft1024_e2k_interleave(FFTComplex *z)

+{

+    fft512_e2k_interleave(z);

+    fft256_e2k_interleave(z+512);

+    fft256_e2k_interleave(z+768);

+    pass_e2k_interleave(z,ff_cos_1024,128);

+}

+

+static void fft2048_e2k_interleave(FFTComplex *z)

+{

+    fft1024_e2k_interleave(z);

+    fft512_e2k_interleave(z+1024);

+    fft512_e2k_interleave(z+1536);

+    pass_e2k_interleave(z,ff_cos_2048,256);

+}

+

+static void fft4096_e2k_interleave(FFTComplex *z)

+{

+    fft2048_e2k_interleave(z);

+    fft1024_e2k_interleave(z+2048);

+    fft1024_e2k_interleave(z+3072);

+    pass_e2k_interleave(z,ff_cos_4096, 512);

+}

+

+static void fft8192_e2k_interleave(FFTComplex *z)

+{

+    fft4096_e2k_interleave(z);

+    fft2048_e2k_interleave(z+4096);

+    fft2048_e2k_interleave(z+6144);

+    pass_e2k_interleave(z,ff_cos_8192,1024);

+}

+

+static void fft16384_e2k_interleave(FFTComplex *z)

+{

+    fft8192_e2k_interleave(z);

+    fft4096_e2k_interleave(z+8192);

+    fft4096_e2k_interleave(z+12288);

+    pass_e2k_interleave(z,ff_cos_16384,2048);

+}

+

+static void fft32768_e2k_interleave(FFTComplex *z)

+{

+    fft16384_e2k_interleave(z);

+    fft8192_e2k_interleave(z+16384);

+    fft8192_e2k_interleave(z+24576);

+    pass_e2k_interleave(z,ff_cos_32768,4096);

+}

+

+static void fft65536_e2k_interleave(FFTComplex *z)

+{

+    fft32768_e2k_interleave(z);

+    fft16384_e2k_interleave(z+32768);

+    fft16384_e2k_interleave(z+49152);

+    pass_e2k_interleave(z,ff_cos_65536,8192);

+}

+

+static void fft32_e2k(FFTComplex *z)

+{

+    fft16_e2k(z);

+    fft8_e2k(z+16);

+    fft8_e2k(z+24);

+    pass_e2k(z,ff_cos_32,4);

+}

+

+static void fft64_e2k(FFTComplex *z)

+{

+    fft32_e2k(z);

+    fft16_e2k(z+32);

+    fft16_e2k(z+48);

+    pass_e2k(z,ff_cos_64, 8);

+}

+

+static void fft128_e2k(FFTComplex *z)

+{

+    fft64_e2k(z);

+    fft32_e2k(z+64);

+    fft32_e2k(z+96);

+    pass_e2k(z,ff_cos_128,16);

+}

+

+static void fft256_e2k(FFTComplex *z)

+{

+    fft128_e2k(z);

+    fft64_e2k(z+128);

+    fft64_e2k(z+192);

+    pass_e2k(z,ff_cos_256,32);

+}

+

+static void fft512_e2k(FFTComplex *z)

+{

+    fft256_e2k(z);

+    fft128_e2k(z+256);

+    fft128_e2k(z+384);

+    pass_e2k(z,ff_cos_512,64);

+}

+

+static void fft1024_e2k(FFTComplex *z)

+{

+    fft512_e2k(z);

+    fft256_e2k(z+512);

+    fft256_e2k(z+768);

+    pass_e2k(z,ff_cos_1024,128);

+

+}

+

+static void fft2048_e2k(FFTComplex *z)

+{

+    fft1024_e2k(z);

+    fft512_e2k(z+1024);

+    fft512_e2k(z+1536);

+    pass_e2k(z,ff_cos_2048,256);

+}

+

+static void fft4096_e2k(FFTComplex *z)

+{

+    fft2048_e2k(z);

+    fft1024_e2k(z+2048);

+    fft1024_e2k(z+3072);

+    pass_e2k(z,ff_cos_4096, 512);

+}

+

+static void fft8192_e2k(FFTComplex *z)

+{

+    fft4096_e2k(z);

+    fft2048_e2k(z+4096);

+    fft2048_e2k(z+6144);

+    pass_e2k(z,ff_cos_8192,1024);

+}

+

+static void fft16384_e2k(FFTComplex *z)

+{

+    fft8192_e2k(z);

+    fft4096_e2k(z+8192);

+    fft4096_e2k(z+12288);

+    pass_e2k(z,ff_cos_16384,2048);

+}

+

+static void fft32768_e2k(FFTComplex *z)

+{

+    fft16384_e2k(z);

+    fft8192_e2k(z+16384);

+    fft8192_e2k(z+24576);

+    pass_e2k(z,ff_cos_32768,4096);

+}

+

+static void fft65536_e2k(FFTComplex *z)

+{

+    fft32768_e2k(z);

+    fft16384_e2k(z+32768);

+    fft16384_e2k(z+49152);

+    pass_e2k(z,ff_cos_65536,8192);

+}

+

+static void (* const fft_dispatch_e2k[])(FFTComplex*) = {

+    fft4_e2k, fft8_e2k, fft16_e2k, fft32_e2k, fft64_e2k, fft128_e2k, fft256_e2k, fft512_e2k, fft1024_e2k,

+    fft2048_e2k, fft4096_e2k, fft8192_e2k, fft16384_e2k, fft32768_e2k, fft65536_e2k,

+};

+

+static void (* const fft_dispatch_e2k_interleave[])(FFTComplex*) = {

+    fft4_e2k_interleave, fft8_e2k_interleave, fft16_e2k_interleave, fft32_e2k_interleave, fft64_e2k_interleave,

+    fft128_e2k_interleave, fft256_e2k_interleave, fft512_e2k_interleave, fft1024_e2k_interleave,

+    fft2048_e2k_interleave, fft4096_e2k_interleave, fft8192_e2k_interleave, fft16384_e2k_interleave, fft32768_e2k_interleave, fft65536_e2k_interleave,

+};

+

+void ff_fft_calc_interleave_e2k(FFTContext *s, FFTComplex *z)

+{

+     fft_dispatch_e2k_interleave[s->nbits-2](z);

+}

+

+void ff_fft_calc_e2k(FFTContext *s, FFTComplex *z)

+{

+     fft_dispatch_e2k[s->nbits-2](z);

+}

+

diff --git a/libavcodec/e2k/fft.h b/libavcodec/e2k/fft.h

new file mode 100644

index 0000000..62ae2f3

--- /dev/null

+++ b/libavcodec/e2k/fft.h

@@ -0,0 +1,29 @@

+/*

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA