x86inc: Support creating global symbols from local labels
[ffmpeg.git] / libavutil / float_dsp.c
index be85d20..1d4911d 100644 (file)
@@ -22,6 +22,7 @@
 #include "config.h"
 #include "attributes.h"
 #include "float_dsp.h"
+#include "mem.h"
 
 static void vector_fmul_c(float *dst, const float *src0, const float *src1,
                           int len)
@@ -39,6 +40,14 @@ static void vector_fmac_scalar_c(float *dst, const float *src, float mul,
         dst[i] += src[i] * mul;
 }
 
+static void vector_dmac_scalar_c(double *dst, const double *src, double mul,
+                                 int len)
+{
+    int i;
+    for (i = 0; i < len; i++)
+        dst[i] += src[i] * mul;
+}
+
 static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
                                  int len)
 {
@@ -115,11 +124,16 @@ float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
     return p;
 }
 
-av_cold void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
+av_cold AVFloatDSPContext *avpriv_float_dsp_alloc(int bit_exact)
 {
+    AVFloatDSPContext *fdsp = av_mallocz(sizeof(AVFloatDSPContext));
+    if (!fdsp)
+        return NULL;
+
     fdsp->vector_fmul = vector_fmul_c;
     fdsp->vector_fmac_scalar = vector_fmac_scalar_c;
     fdsp->vector_fmul_scalar = vector_fmul_scalar_c;
+    fdsp->vector_dmac_scalar = vector_dmac_scalar_c;
     fdsp->vector_dmul_scalar = vector_dmul_scalar_c;
     fdsp->vector_fmul_window = vector_fmul_window_c;
     fdsp->vector_fmul_add = vector_fmul_add_c;
@@ -127,298 +141,15 @@ av_cold void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
     fdsp->butterflies_float = butterflies_float_c;
     fdsp->scalarproduct_float = avpriv_scalarproduct_float_c;
 
-#if   ARCH_AARCH64
-    ff_float_dsp_init_aarch64(fdsp);
-#elif ARCH_ARM
-    ff_float_dsp_init_arm(fdsp);
-#elif ARCH_PPC
-    ff_float_dsp_init_ppc(fdsp, bit_exact);
-#elif ARCH_X86
-    ff_float_dsp_init_x86(fdsp);
-#elif ARCH_MIPS
-    ff_float_dsp_init_mips(fdsp);
-#endif
-}
-
-#ifdef TEST
-
-#include <float.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "cpu.h"
-#include "lfg.h"
-#include "log.h"
-#include "mem.h"
-#include "random_seed.h"
-
-#define LEN 240
-
-static void fill_float_array(AVLFG *lfg, float *a, int len)
-{
-    int i;
-    double bmg[2], stddev = 10.0, mean = 0.0;
-
-    for (i = 0; i < len; i += 2) {
-        av_bmg_get(lfg, bmg);
-        a[i]     = bmg[0] * stddev + mean;
-        a[i + 1] = bmg[1] * stddev + mean;
-    }
-}
-static int compare_floats(const float *a, const float *b, int len,
-                          float max_diff)
-{
-    int i;
-    for (i = 0; i < len; i++) {
-        if (fabsf(a[i] - b[i]) > max_diff) {
-            av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
-                   i, a[i], b[i], a[i] - b[i]);
-            return -1;
-        }
-    }
-    return 0;
-}
-
-static void fill_double_array(AVLFG *lfg, double *a, int len)
-{
-    int i;
-    double bmg[2], stddev = 10.0, mean = 0.0;
-
-    for (i = 0; i < len; i += 2) {
-        av_bmg_get(lfg, bmg);
-        a[i]     = bmg[0] * stddev + mean;
-        a[i + 1] = bmg[1] * stddev + mean;
-    }
-}
-
-static int compare_doubles(const double *a, const double *b, int len,
-                           double max_diff)
-{
-    int i;
-
-    for (i = 0; i < len; i++) {
-        if (fabs(a[i] - b[i]) > max_diff) {
-            av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
-                   i, a[i], b[i], a[i] - b[i]);
-            return -1;
-        }
-    }
-    return 0;
+    if (ARCH_AARCH64)
+        ff_float_dsp_init_aarch64(fdsp);
+    if (ARCH_ARM)
+        ff_float_dsp_init_arm(fdsp);
+    if (ARCH_PPC)
+        ff_float_dsp_init_ppc(fdsp, bit_exact);
+    if (ARCH_X86)
+        ff_float_dsp_init_x86(fdsp);
+    if (ARCH_MIPS)
+        ff_float_dsp_init_mips(fdsp);
+    return fdsp;
 }
-
-static int test_vector_fmul(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                            const float *v1, const float *v2)
-{
-    DECLARE_ALIGNED(32, float, cdst)[LEN];
-    DECLARE_ALIGNED(32, float, odst)[LEN];
-    int ret;
-
-    cdsp->vector_fmul(cdst, v1, v2, LEN);
-    fdsp->vector_fmul(odst, v1, v2, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-#define ARBITRARY_FMAC_SCALAR_CONST 0.005
-static int test_vector_fmac_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const float *v1, const float *src0, float scale)
-{
-    DECLARE_ALIGNED(32, float, cdst)[LEN];
-    DECLARE_ALIGNED(32, float, odst)[LEN];
-    int ret;
-
-    memcpy(cdst, v1, LEN * sizeof(*v1));
-    memcpy(odst, v1, LEN * sizeof(*v1));
-
-    cdsp->vector_fmac_scalar(cdst, src0, scale, LEN);
-    fdsp->vector_fmac_scalar(odst, src0, scale, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMAC_SCALAR_CONST))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-static int test_vector_fmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const float *v1, float scale)
-{
-    DECLARE_ALIGNED(32, float, cdst)[LEN];
-    DECLARE_ALIGNED(32, float, odst)[LEN];
-    int ret;
-
-    cdsp->vector_fmul_scalar(cdst, v1, scale, LEN);
-    fdsp->vector_fmul_scalar(odst, v1, scale, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-static int test_vector_dmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const double *v1, double scale)
-{
-    DECLARE_ALIGNED(32, double, cdst)[LEN];
-    DECLARE_ALIGNED(32, double, odst)[LEN];
-    int ret;
-
-    cdsp->vector_dmul_scalar(cdst, v1, scale, LEN);
-    fdsp->vector_dmul_scalar(odst, v1, scale, LEN);
-
-    if (ret = compare_doubles(cdst, odst, LEN, DBL_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-#define ARBITRARY_FMUL_WINDOW_CONST 0.008
-static int test_vector_fmul_window(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const float *v1, const float *v2, const float *v3)
-{
-    DECLARE_ALIGNED(32, float, cdst)[LEN];
-    DECLARE_ALIGNED(32, float, odst)[LEN];
-    int ret;
-
-    cdsp->vector_fmul_window(cdst, v1, v2, v3, LEN / 2);
-    fdsp->vector_fmul_window(odst, v1, v2, v3, LEN / 2);
-
-    if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_WINDOW_CONST))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-#define ARBITRARY_FMUL_ADD_CONST 0.005
-static int test_vector_fmul_add(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                const float *v1, const float *v2, const float *v3)
-{
-    DECLARE_ALIGNED(32, float, cdst)[LEN];
-    DECLARE_ALIGNED(32, float, odst)[LEN];
-    int ret;
-
-    cdsp->vector_fmul_add(cdst, v1, v2, v3, LEN);
-    fdsp->vector_fmul_add(odst, v1, v2, v3, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_ADD_CONST))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-static int test_vector_fmul_reverse(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                    const float *v1, const float *v2)
-{
-    DECLARE_ALIGNED(32, float, cdst)[LEN];
-    DECLARE_ALIGNED(32, float, odst)[LEN];
-    int ret;
-
-    cdsp->vector_fmul_reverse(cdst, v1, v2, LEN);
-    fdsp->vector_fmul_reverse(odst, v1, v2, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-static int test_butterflies_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                  const float *v1, const float *v2)
-{
-    DECLARE_ALIGNED(32, float, cv1)[LEN];
-    DECLARE_ALIGNED(32, float, cv2)[LEN];
-    DECLARE_ALIGNED(32, float, ov1)[LEN];
-    DECLARE_ALIGNED(32, float, ov2)[LEN];
-    int ret;
-
-    memcpy(cv1, v1, LEN * sizeof(*v1));
-    memcpy(cv2, v2, LEN * sizeof(*v2));
-    memcpy(ov1, v1, LEN * sizeof(*v1));
-    memcpy(ov2, v2, LEN * sizeof(*v2));
-
-    cdsp->butterflies_float(cv1, cv2, LEN);
-    fdsp->butterflies_float(ov1, ov2, LEN);
-
-    if ((ret = compare_floats(cv1, ov1, LEN, FLT_EPSILON)) ||
-        (ret = compare_floats(cv2, ov2, LEN, FLT_EPSILON)))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-#define ARBITRARY_SCALARPRODUCT_CONST 0.2
-static int test_scalarproduct_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                    const float *v1, const float *v2)
-{
-    float cprod, oprod;
-    int ret;
-
-    cprod = cdsp->scalarproduct_float(v1, v2, LEN);
-    oprod = fdsp->scalarproduct_float(v1, v2, LEN);
-
-    if (ret = compare_floats(&cprod, &oprod, 1, ARBITRARY_SCALARPRODUCT_CONST))
-        av_log(NULL, AV_LOG_ERROR, "%s failed\n", __func__);
-
-    return ret;
-}
-
-int main(int argc, char **argv)
-{
-    int ret = 0;
-    uint32_t seed;
-    AVFloatDSPContext fdsp, cdsp;
-    AVLFG lfg;
-
-    DECLARE_ALIGNED(32, float, src0)[LEN];
-    DECLARE_ALIGNED(32, float, src1)[LEN];
-    DECLARE_ALIGNED(32, float, src2)[LEN];
-    DECLARE_ALIGNED(32, double, dbl_src0)[LEN];
-    DECLARE_ALIGNED(32, double, dbl_src1)[LEN];
-
-    if (argc > 2 && !strcmp(argv[1], "-s"))
-        seed = strtoul(argv[2], NULL, 10);
-    else
-        seed = av_get_random_seed();
-
-    av_log(NULL, AV_LOG_INFO, "float_dsp-test: random seed %u\n", seed);
-
-    av_lfg_init(&lfg, seed);
-
-    fill_float_array(&lfg, src0, LEN);
-    fill_float_array(&lfg, src1, LEN);
-    fill_float_array(&lfg, src2, LEN);
-
-    fill_double_array(&lfg, dbl_src0, LEN);
-    fill_double_array(&lfg, dbl_src1, LEN);
-
-    avpriv_float_dsp_init(&fdsp, 1);
-    av_set_cpu_flags_mask(0);
-    avpriv_float_dsp_init(&cdsp, 1);
-
-    if (test_vector_fmul(&fdsp, &cdsp, src0, src1))
-        ret -= 1 << 0;
-    if (test_vector_fmac_scalar(&fdsp, &cdsp, src2, src0, src1[0]))
-        ret -= 1 << 1;
-    if (test_vector_fmul_scalar(&fdsp, &cdsp, src0, src1[0]))
-        ret -= 1 << 2;
-    if (test_vector_fmul_window(&fdsp, &cdsp, src0, src1, src2))
-        ret -= 1 << 3;
-    if (test_vector_fmul_add(&fdsp, &cdsp, src0, src1, src2))
-        ret -= 1 << 4;
-    if (test_vector_fmul_reverse(&fdsp, &cdsp, src0, src1))
-        ret -= 1 << 5;
-    if (test_butterflies_float(&fdsp, &cdsp, src0, src1))
-        ret -= 1 << 6;
-    if (test_scalarproduct_float(&fdsp, &cdsp, src0, src1))
-        ret -= 1 << 7;
-    if (test_vector_dmul_scalar(&fdsp, &cdsp, dbl_src0, dbl_src1[0]))
-        ret -= 1 << 8;
-
-    return ret;
-}
-
-#endif /* TEST */