From: David Schleef Date: Mon, 7 Jun 2010 06:45:58 +0000 (-0700) Subject: adder: convert from liboil to orc X-Git-Tag: 1.19.3~511^2~8391 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c4ab9c0de8de21d718ce250da5eb56e060778b68;p=platform%2Fupstream%2Fgstreamer.git adder: convert from liboil to orc --- diff --git a/gst/adder/Makefile.am b/gst/adder/Makefile.am index 7ec0a40..f8969a4 100644 --- a/gst/adder/Makefile.am +++ b/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) -#$(LIBOIL_CFLAGS) +nodist_libgstadder_la_SOURCES = $(ORC_NODIST_SOURCES) +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) -#$(LIBOIL_LIBS) + $(GST_BASE_LIBS) $(GST_LIBS) $(ORC_LIBS) libgstadder_la_LIBTOOLFLAGS = --tag=disable-static noinst_HEADERS = gstadder.h + + + diff --git a/gst/adder/gstadder.c b/gst/adder/gstadder.c index d5b7466..184421d 100644 --- a/gst/adder/gstadder.c +++ b/gst/adder/gstadder.c @@ -46,7 +46,7 @@ #include "gstadder.h" #include #include /* strcmp */ -/*#include */ +#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; } diff --git a/gst/adder/gstadder.h b/gst/adder/gstadder.h index 1f78c75..f0151b4 100644 --- a/gst/adder/gstadder.h +++ b/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; diff --git a/gst/adder/gstadderorc-dist.c b/gst/adder/gstadderorc-dist.c new file mode 100644 index 0000000..16e7425 --- /dev/null +++ b/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 +#else +#include +#endif +#include + +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 diff --git a/gst/adder/gstadderorc-dist.h b/gst/adder/gstadderorc-dist.h new file mode 100644 index 0000000..f00060a --- /dev/null +++ b/gst/adder/gstadderorc-dist.h @@ -0,0 +1,26 @@ + +/* autogenerated from gstadderorc.orc */ + +#ifndef _GSTADDERORC_H_ +#define _GSTADDERORC_H_ + +#include + +#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 + diff --git a/gst/adder/gstadderorc.orc b/gst/adder/gstadderorc.orc new file mode 100644 index 0000000..e37f4a9 --- /dev/null +++ b/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 + +