adder: convert from liboil to orc

gst/adder/Makefile.am

@@ -1,13 +1,19 @@
 plugin_LTLIBRARIES = libgstadder.la
 
+ORC_SOURCE=gstadderorc
+include $(top_srcdir)/common/orc.mak
+
+
 libgstadder_la_SOURCES = gstadder.c
-libgstadder_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS)
+nodist_libgstadder_la_SOURCES = $(ORC_NODIST_SOURCES)
-#$(LIBOIL_CFLAGS)
+libgstadder_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS) $(ORC_CFLAGS)
 libgstadder_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
 libgstadder_la_LIBADD =  \
 	         $(top_builddir)/gst-libs/gst/audio/libgstaudio-@GST_MAJORMINOR@.la \
-		 $(GST_BASE_LIBS) $(GST_LIBS)
+		 $(GST_BASE_LIBS) $(GST_LIBS) $(ORC_LIBS)
-#$(LIBOIL_LIBS)
 libgstadder_la_LIBTOOLFLAGS = --tag=disable-static
 
 noinst_HEADERS = gstadder.h
+
+
+

gst/adder/gstadder.c

@@ -46,7 +46,7 @@
 #include "gstadder.h"
 #include <gst/audio/audio.h>
 #include <string.h>             /* strcmp */
-/*#include <liboil/liboil.h>*/
+#include "gstadderorc.h"
 
 /* highest positive/lowest negative x-bit value we can use for clamping */
 #define MAX_INT_32  ((gint32) (0x7fffffff))
@@ -164,65 +164,16 @@ gst_adder_get_type (void)
   return adder_type;
 }
 
-/* clipping versions (for int)
- * FIXME: what about: oil_add_s16 (out, out, in, bytes / sizeof (type))
- */
-#define MAKE_FUNC(name,type,ttype,min,max)                      \
-static void name (type *out, type *in, gint bytes) {            \
-  gint i;                                                       \
-  ttype add;                                                    \
-  for (i = 0; i < bytes / sizeof (type); i++) {                 \
-    add = (ttype)out[i] + (ttype)in[i];                         \
-    out[i] = CLAMP (add, min, max);                             \
-  }                                                             \
-}
-
-/* unsigned versions (for int) */
-#define MAKE_FUNC_US(name,type,ttype,max)                       \
-static void name (type *out, type *in, gint bytes) {            \
-  gint i;                                                       \
-  ttype add;                                                    \
-  for (i = 0; i < bytes / sizeof (type); i++) {                 \
-    add = (ttype)out[i] + (ttype)in[i];                         \
-    out[i] = ((add <= max) ? add : max);                        \
-  }                                                             \
-}
-
 /* non-clipping versions (for float) */
 #define MAKE_FUNC_NC(name,type)                                 \
-static void name (type *out, type *in, gint bytes) {            \
+static void name (type *out, type *in, gint samples) {          \
   gint i;                                                       \
-  for (i = 0; i < bytes / sizeof (type); i++)                   \
+  for (i = 0; i < samples; i++)                                 \
     out[i] += in[i];                                            \
 }
 
-#if 0
-/* right now, the liboil function don't seems to be faster on x86
- * time gst-launch audiotestsrc num-buffers=50000 ! audio/x-raw-float ! adder name=m ! fakesink audiotestsrc num-buffers=50000 ! audio/x-raw-float ! m.
- * time gst-launch audiotestsrc num-buffers=50000 ! audio/x-raw-float,width=32 ! adder name=m ! fakesink audiotestsrc num-buffers=50000 ! audio/x-raw-float,width=32 ! m.
- */
-static void
-add_float32 (gfloat * out, gfloat * in, gint bytes)
-{
-  oil_add_f32 (out, out, in, bytes / sizeof (gfloat));
-}
-
-static void
-add_float64 (gdouble * out, gdouble * in, gint bytes)
-{
-  oil_add_f64 (out, out, in, bytes / sizeof (gdouble));
-}
-#endif
-
 /* *INDENT-OFF* */
-MAKE_FUNC (add_int32, gint32, gint64, MIN_INT_32, MAX_INT_32)
-MAKE_FUNC (add_int16, gint16, gint32, MIN_INT_16, MAX_INT_16)
-MAKE_FUNC (add_int8, gint8, gint16, MIN_INT_8, MAX_INT_8)
-MAKE_FUNC_US (add_uint32, guint32, guint64, MAX_UINT_32)
-MAKE_FUNC_US (add_uint16, guint16, guint32, MAX_UINT_16)
-MAKE_FUNC_US (add_uint8, guint8, guint16, MAX_UINT_8)
 MAKE_FUNC_NC (add_float64, gdouble)
-MAKE_FUNC_NC (add_float32, gfloat)
 /* *INDENT-ON* */
 
 /* we can only accept caps that we and downstream can handle.
@@ -334,14 +285,17 @@ gst_adder_setcaps (GstPad * pad, GstCaps * caps)
       case 8:
         adder->func = (adder->is_signed ?
             (GstAdderFunction) add_int8 : (GstAdderFunction) add_uint8);
+        adder->sample_size = 1;
         break;
       case 16:
         adder->func = (adder->is_signed ?
             (GstAdderFunction) add_int16 : (GstAdderFunction) add_uint16);
+        adder->sample_size = 2;
         break;
       case 32:
         adder->func = (adder->is_signed ?
             (GstAdderFunction) add_int32 : (GstAdderFunction) add_uint32);
+        adder->sample_size = 4;
         break;
       default:
         goto not_supported;
@@ -360,9 +314,11 @@ gst_adder_setcaps (GstPad * pad, GstCaps * caps)
     switch (adder->width) {
       case 32:
         adder->func = (GstAdderFunction) add_float32;
+        adder->sample_size = 4;
         break;
       case 64:
         adder->func = (GstAdderFunction) add_float64;
+        adder->sample_size = 8;
         break;
       default:
         goto not_supported;
@@ -1178,7 +1134,8 @@ gst_adder_collected (GstCollectPads * pads, gpointer user_data)
             collect_data, insize, indata);
 
         /* further buffers, need to add them */
-        adder->func ((gpointer) outdata, (gpointer) indata, insize);
+        adder->func ((gpointer) outdata, (gpointer) indata,
+            insize / adder->sample_size);
       } else {
         /* skip gap buffer */
         GST_LOG_OBJECT (adder, "channel %p: skipping GAP buffer", collect_data);
@@ -1347,8 +1304,6 @@ gst_adder_change_state (GstElement * element, GstStateChange transition)
 static gboolean
 plugin_init (GstPlugin * plugin)
 {
-  /*oil_init (); */
-
   if (!gst_element_register (plugin, "adder", GST_RANK_NONE, GST_TYPE_ADDER)) {
     return FALSE;
   }

gst/adder/gstadder.h

@@ -66,6 +66,7 @@ struct _GstAdder {
   gint            channels;
   gint            width;
   gint            endianness;
+  int             sample_size;
 
   /* the next are valid only for format == GST_ADDER_FORMAT_INT */
   gint            depth;

gst/adder/gstadderorc-dist.c

@@ -0,0 +1,695 @@
+
+/* autogenerated from gstadderorc.orc */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifndef DISABLE_ORC
+#include <orc/orc.h>
+#else
+#include <stdint.h>
+#endif
+#include <glib.h>
+
+void add_int32 (gint32 * d1, const gint32 * s1, int n);
+void add_int16 (gint16 * d1, const gint16 * s1, int n);
+void add_int8 (gint8 * d1, const gint8 * s1, int n);
+void add_uint32 (guint32 * d1, const guint32 * s1, int n);
+void add_uint16 (guint16 * d1, const guint16 * s1, int n);
+void add_uint8 (guint8 * d1, const guint8 * s1, int n);
+void add_float32 (float *d1, const float *s1, int n);
+
+
+/* begin Orc C target preamble */
+#define ORC_CLAMP(x,a,b) ((x)<(a) ? (a) : ((x)>(b) ? (b) : (x)))
+#define ORC_ABS(a) ((a)<0 ? -(a) : (a))
+#define ORC_MIN(a,b) ((a)<(b) ? (a) : (b))
+#define ORC_MAX(a,b) ((a)>(b) ? (a) : (b))
+#define ORC_SB_MAX 127
+#define ORC_SB_MIN (-1-ORC_SB_MAX)
+#define ORC_UB_MAX 255
+#define ORC_UB_MIN 0
+#define ORC_SW_MAX 32767
+#define ORC_SW_MIN (-1-ORC_SW_MAX)
+#define ORC_UW_MAX 65535
+#define ORC_UW_MIN 0
+#define ORC_SL_MAX 2147483647
+#define ORC_SL_MIN (-1-ORC_SL_MAX)
+#define ORC_UL_MAX 4294967295U
+#define ORC_UL_MIN 0
+#define ORC_CLAMP_SB(x) ORC_CLAMP(x,ORC_SB_MIN,ORC_SB_MAX)
+#define ORC_CLAMP_UB(x) ORC_CLAMP(x,ORC_UB_MIN,ORC_UB_MAX)
+#define ORC_CLAMP_SW(x) ORC_CLAMP(x,ORC_SW_MIN,ORC_SW_MAX)
+#define ORC_CLAMP_UW(x) ORC_CLAMP(x,ORC_UW_MIN,ORC_UW_MAX)
+#define ORC_CLAMP_SL(x) ORC_CLAMP(x,ORC_SL_MIN,ORC_SL_MAX)
+#define ORC_CLAMP_UL(x) ORC_CLAMP(x,ORC_UL_MIN,ORC_UL_MAX)
+#define ORC_SWAP_W(x) ((((x)&0xff)<<8) | (((x)&0xff00)>>8))
+#define ORC_SWAP_L(x) ((((x)&0xff)<<24) | (((x)&0xff00)<<8) | (((x)&0xff0000)>>8) | (((x)&0xff000000)>>24))
+#define ORC_PTR_OFFSET(ptr,offset) ((void *)(((unsigned char *)(ptr)) + (offset)))
+#define ORC_AS_FLOAT(x) (((union { int i; float f; } *)(&x))->f)
+typedef union
+{
+  int32_t i;
+  float f;
+} orc_union32;
+typedef union
+{
+  int64_t i;
+  double f;
+} orc_union64;
+/* end Orc C target preamble */
+
+
+
+/* add_int32 */
+#ifdef DISABLE_ORC
+void
+add_int32 (gint32 * d1, const gint32 * s1, int n)
+{
+  int i;
+  orc_union32 var0;
+  orc_union32 *ptr0;
+  orc_union32 var4;
+  const orc_union32 *ptr4;
+
+  ptr0 = (orc_union32 *) d1;
+  ptr4 = (orc_union32 *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addssl */
+    var0.i = ORC_CLAMP_SL ((int64_t) var0.i + (int64_t) var4.i);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_int32 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  orc_union32 var0;
+  orc_union32 *ptr0;
+  orc_union32 var4;
+  const orc_union32 *ptr4;
+
+  ptr0 = (orc_union32 *) ex->arrays[0];
+  ptr4 = (orc_union32 *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addssl */
+    var0.i = ORC_CLAMP_SL ((int64_t) var0.i + (int64_t) var4.i);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_int32 (gint32 * d1, const gint32 * s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_int32");
+      orc_program_set_backup_function (p, _backup_add_int32);
+      orc_program_add_destination (p, 4, "d1");
+      orc_program_add_source (p, 4, "s1");
+
+      orc_program_append (p, "addssl", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif
+
+
+/* add_int16 */
+#ifdef DISABLE_ORC
+void
+add_int16 (gint16 * d1, const gint16 * s1, int n)
+{
+  int i;
+  int16_t var0;
+  int16_t *ptr0;
+  int16_t var4;
+  const int16_t *ptr4;
+
+  ptr0 = (int16_t *) d1;
+  ptr4 = (int16_t *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addssw */
+    var0 = ORC_CLAMP_SW (var0 + var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_int16 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  int16_t var0;
+  int16_t *ptr0;
+  int16_t var4;
+  const int16_t *ptr4;
+
+  ptr0 = (int16_t *) ex->arrays[0];
+  ptr4 = (int16_t *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addssw */
+    var0 = ORC_CLAMP_SW (var0 + var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_int16 (gint16 * d1, const gint16 * s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_int16");
+      orc_program_set_backup_function (p, _backup_add_int16);
+      orc_program_add_destination (p, 2, "d1");
+      orc_program_add_source (p, 2, "s1");
+
+      orc_program_append (p, "addssw", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif
+
+
+/* add_int8 */
+#ifdef DISABLE_ORC
+void
+add_int8 (gint8 * d1, const gint8 * s1, int n)
+{
+  int i;
+  int8_t var0;
+  int8_t *ptr0;
+  int8_t var4;
+  const int8_t *ptr4;
+
+  ptr0 = (int8_t *) d1;
+  ptr4 = (int8_t *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addssb */
+    var0 = ORC_CLAMP_SB (var0 + var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_int8 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  int8_t var0;
+  int8_t *ptr0;
+  int8_t var4;
+  const int8_t *ptr4;
+
+  ptr0 = (int8_t *) ex->arrays[0];
+  ptr4 = (int8_t *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addssb */
+    var0 = ORC_CLAMP_SB (var0 + var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_int8 (gint8 * d1, const gint8 * s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_int8");
+      orc_program_set_backup_function (p, _backup_add_int8);
+      orc_program_add_destination (p, 1, "d1");
+      orc_program_add_source (p, 1, "s1");
+
+      orc_program_append (p, "addssb", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif
+
+
+/* add_uint32 */
+#ifdef DISABLE_ORC
+void
+add_uint32 (guint32 * d1, const guint32 * s1, int n)
+{
+  int i;
+  orc_union32 var0;
+  orc_union32 *ptr0;
+  orc_union32 var4;
+  const orc_union32 *ptr4;
+
+  ptr0 = (orc_union32 *) d1;
+  ptr4 = (orc_union32 *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addusl */
+    var0.i =
+        ORC_CLAMP_UL ((int64_t) (uint32_t) var0.i +
+        (int64_t) (uint32_t) var4.i);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_uint32 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  orc_union32 var0;
+  orc_union32 *ptr0;
+  orc_union32 var4;
+  const orc_union32 *ptr4;
+
+  ptr0 = (orc_union32 *) ex->arrays[0];
+  ptr4 = (orc_union32 *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addusl */
+    var0.i =
+        ORC_CLAMP_UL ((int64_t) (uint32_t) var0.i +
+        (int64_t) (uint32_t) var4.i);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_uint32 (guint32 * d1, const guint32 * s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_uint32");
+      orc_program_set_backup_function (p, _backup_add_uint32);
+      orc_program_add_destination (p, 4, "d1");
+      orc_program_add_source (p, 4, "s1");
+
+      orc_program_append (p, "addusl", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif
+
+
+/* add_uint16 */
+#ifdef DISABLE_ORC
+void
+add_uint16 (guint16 * d1, const guint16 * s1, int n)
+{
+  int i;
+  int16_t var0;
+  int16_t *ptr0;
+  int16_t var4;
+  const int16_t *ptr4;
+
+  ptr0 = (int16_t *) d1;
+  ptr4 = (int16_t *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addusw */
+    var0 = ORC_CLAMP_UW ((uint16_t) var0 + (uint16_t) var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_uint16 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  int16_t var0;
+  int16_t *ptr0;
+  int16_t var4;
+  const int16_t *ptr4;
+
+  ptr0 = (int16_t *) ex->arrays[0];
+  ptr4 = (int16_t *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addusw */
+    var0 = ORC_CLAMP_UW ((uint16_t) var0 + (uint16_t) var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_uint16 (guint16 * d1, const guint16 * s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_uint16");
+      orc_program_set_backup_function (p, _backup_add_uint16);
+      orc_program_add_destination (p, 2, "d1");
+      orc_program_add_source (p, 2, "s1");
+
+      orc_program_append (p, "addusw", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif
+
+
+/* add_uint8 */
+#ifdef DISABLE_ORC
+void
+add_uint8 (guint8 * d1, const guint8 * s1, int n)
+{
+  int i;
+  int8_t var0;
+  int8_t *ptr0;
+  int8_t var4;
+  const int8_t *ptr4;
+
+  ptr0 = (int8_t *) d1;
+  ptr4 = (int8_t *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addusb */
+    var0 = ORC_CLAMP_UB ((uint8_t) var0 + (uint8_t) var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_uint8 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  int8_t var0;
+  int8_t *ptr0;
+  int8_t var4;
+  const int8_t *ptr4;
+
+  ptr0 = (int8_t *) ex->arrays[0];
+  ptr4 = (int8_t *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addusb */
+    var0 = ORC_CLAMP_UB ((uint8_t) var0 + (uint8_t) var4);
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_uint8 (guint8 * d1, const guint8 * s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_uint8");
+      orc_program_set_backup_function (p, _backup_add_uint8);
+      orc_program_add_destination (p, 1, "d1");
+      orc_program_add_source (p, 1, "s1");
+
+      orc_program_append (p, "addusb", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif
+
+
+/* add_float32 */
+#ifdef DISABLE_ORC
+void
+add_float32 (float *d1, const float *s1, int n)
+{
+  int i;
+  orc_union32 var0;
+  orc_union32 *ptr0;
+  orc_union32 var4;
+  const orc_union32 *ptr4;
+
+  ptr0 = (orc_union32 *) d1;
+  ptr4 = (orc_union32 *) s1;
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addf */
+    var0.f = var0.f + var4.f;
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+#else
+static void
+_backup_add_float32 (OrcExecutor * ex)
+{
+  int i;
+  int n = ex->n;
+  orc_union32 var0;
+  orc_union32 *ptr0;
+  orc_union32 var4;
+  const orc_union32 *ptr4;
+
+  ptr0 = (orc_union32 *) ex->arrays[0];
+  ptr4 = (orc_union32 *) ex->arrays[4];
+
+  for (i = 0; i < n; i++) {
+    var0 = *ptr0;
+    var4 = *ptr4;
+    ptr4++;
+    /* 0: addf */
+    var0.f = var0.f + var4.f;
+    *ptr0 = var0;
+    ptr0++;
+  }
+
+}
+
+void
+add_float32 (float *d1, const float *s1, int n)
+{
+  OrcExecutor _ex, *ex = &_ex;
+  static int p_inited = 0;
+  static OrcProgram *p = 0;
+  void (*func) (OrcExecutor *);
+
+  if (!p_inited) {
+    orc_once_mutex_lock ();
+    if (!p_inited) {
+      OrcCompileResult result;
+
+      p = orc_program_new ();
+      orc_program_set_name (p, "add_float32");
+      orc_program_set_backup_function (p, _backup_add_float32);
+      orc_program_add_destination (p, 4, "d1");
+      orc_program_add_source (p, 4, "s1");
+
+      orc_program_append (p, "addf", ORC_VAR_D1, ORC_VAR_D1, ORC_VAR_S1);
+
+      result = orc_program_compile (p);
+    }
+    p_inited = TRUE;
+    orc_once_mutex_unlock ();
+  }
+  ex->program = p;
+
+  ex->n = n;
+  ex->arrays[ORC_VAR_D1] = d1;
+  ex->arrays[ORC_VAR_S1] = (void *) s1;
+
+  func = p->code_exec;
+  func (ex);
+}
+#endif

gst/adder/gstadderorc-dist.h

@@ -0,0 +1,26 @@
+
+/* autogenerated from gstadderorc.orc */
+
+#ifndef _GSTADDERORC_H_
+#define _GSTADDERORC_H_
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void add_int32 (gint32 * d1, const gint32 * s1, int n);
+void add_int16 (gint16 * d1, const gint16 * s1, int n);
+void add_int8 (gint8 * d1, const gint8 * s1, int n);
+void add_uint32 (guint32 * d1, const guint32 * s1, int n);
+void add_uint16 (guint16 * d1, const guint16 * s1, int n);
+void add_uint8 (guint8 * d1, const guint8 * s1, int n);
+void add_float32 (float * d1, const float * s1, int n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

gst/adder/gstadderorc.orc

@@ -0,0 +1,50 @@
+
+.function add_int32
+.dest 4 d1 gint32
+.source 4 s1 gint32
+
+addssl d1, d1, s1
+
+
+.function add_int16
+.dest 2 d1 gint16
+.source 2 s1 gint16
+
+addssw d1, d1, s1
+
+
+.function add_int8
+.dest 1 d1 gint8
+.source 1 s1 gint8
+
+addssb d1, d1, s1
+
+
+.function add_uint32
+.dest 4 d1 guint32
+.source 4 s1 guint32
+
+addusl d1, d1, s1
+
+
+.function add_uint16
+.dest 2 d1 guint16
+.source 2 s1 guint16
+
+addusw d1, d1, s1
+
+
+.function add_uint8
+.dest 1 d1 guint8
+.source 1 s1 guint8
+
+addusb d1, d1, s1
+
+
+.function add_float32
+.dest 4 d1 float
+.source 4 s1 float
+
+addf d1, d1, s1
+
+