diff options
author | Peter D'Hoye <peter.dhoye@gmail.com> | 2009-05-24 21:28:16 +0000 |
---|---|---|
committer | Peter D'Hoye <peter.dhoye@gmail.com> | 2009-05-24 21:28:16 +0000 |
commit | 526b5580dabbfed7cfe5439dc3a90ec727f563c2 (patch) | |
tree | 22b1af92348785daad16714ee5e2b633017e0e48 /apps/plugins/pdbox/PDa/src/d_arithmetic.c | |
parent | 4f2dfcc01b260d946044ef2b6af5fe36cb772c8d (diff) | |
download | rockbox-526b5580dabbfed7cfe5439dc3a90ec727f563c2.tar.gz rockbox-526b5580dabbfed7cfe5439dc3a90ec727f563c2.zip |
Cut the files in half and it might work better (note to self: check your tree is really clean before patching)
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@21070 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/plugins/pdbox/PDa/src/d_arithmetic.c')
-rw-r--r-- | apps/plugins/pdbox/PDa/src/d_arithmetic.c | 842 |
1 files changed, 0 insertions, 842 deletions
diff --git a/apps/plugins/pdbox/PDa/src/d_arithmetic.c b/apps/plugins/pdbox/PDa/src/d_arithmetic.c index 72404ba50d..30744882f4 100644 --- a/apps/plugins/pdbox/PDa/src/d_arithmetic.c +++ b/apps/plugins/pdbox/PDa/src/d_arithmetic.c | |||
@@ -840,845 +840,3 @@ void d_arithmetic_setup(void) | |||
840 | min_setup(); | 840 | min_setup(); |
841 | } | 841 | } |
842 | 842 | ||
843 | /* Copyright (c) 1997-1999 Miller Puckette. | ||
844 | * For information on usage and redistribution, and for a DISCLAIMER OF ALL | ||
845 | * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ | ||
846 | |||
847 | /* arithmetic binops (+, -, *, /). | ||
848 | If no creation argument is given, there are two signal inlets for vector/vector | ||
849 | operation; otherwise it's vector/scalar and the second inlet takes a float | ||
850 | to reset the value. | ||
851 | */ | ||
852 | |||
853 | #include "m_pd.h" | ||
854 | |||
855 | /* ----------------------------- plus ----------------------------- */ | ||
856 | static t_class *plus_class, *scalarplus_class; | ||
857 | |||
858 | typedef struct _plus | ||
859 | { | ||
860 | t_object x_obj; | ||
861 | float x_f; | ||
862 | } t_plus; | ||
863 | |||
864 | typedef struct _scalarplus | ||
865 | { | ||
866 | t_object x_obj; | ||
867 | float x_f; | ||
868 | t_float x_g; /* inlet value */ | ||
869 | } t_scalarplus; | ||
870 | |||
871 | static void *plus_new(t_symbol *s, int argc, t_atom *argv) | ||
872 | { | ||
873 | if (argc > 1) post("+~: extra arguments ignored"); | ||
874 | if (argc) | ||
875 | { | ||
876 | t_scalarplus *x = (t_scalarplus *)pd_new(scalarplus_class); | ||
877 | floatinlet_new(&x->x_obj, &x->x_g); | ||
878 | x->x_g = atom_getfloatarg(0, argc, argv); | ||
879 | outlet_new(&x->x_obj, &s_signal); | ||
880 | x->x_f = 0; | ||
881 | return (x); | ||
882 | } | ||
883 | else | ||
884 | { | ||
885 | t_plus *x = (t_plus *)pd_new(plus_class); | ||
886 | inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); | ||
887 | outlet_new(&x->x_obj, &s_signal); | ||
888 | x->x_f = 0; | ||
889 | return (x); | ||
890 | } | ||
891 | } | ||
892 | |||
893 | t_int *plus_perform(t_int *w) | ||
894 | { | ||
895 | t_sample *in1 = (t_sample *)(w[1]); | ||
896 | t_sample *in2 = (t_sample *)(w[2]); | ||
897 | t_sample *out = (t_sample *)(w[3]); | ||
898 | int n = (int)(w[4]); | ||
899 | while (n--) *out++ = *in1++ + *in2++; | ||
900 | return (w+5); | ||
901 | } | ||
902 | |||
903 | t_int *plus_perf8(t_int *w) | ||
904 | { | ||
905 | t_sample *in1 = (t_sample *)(w[1]); | ||
906 | t_sample *in2 = (t_sample *)(w[2]); | ||
907 | t_sample *out = (t_sample *)(w[3]); | ||
908 | int n = (int)(w[4]); | ||
909 | for (; n; n -= 8, in1 += 8, in2 += 8, out += 8) | ||
910 | { | ||
911 | t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3]; | ||
912 | t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7]; | ||
913 | |||
914 | t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3]; | ||
915 | t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7]; | ||
916 | |||
917 | out[0] = f0 + g0; out[1] = f1 + g1; out[2] = f2 + g2; out[3] = f3 + g3; | ||
918 | out[4] = f4 + g4; out[5] = f5 + g5; out[6] = f6 + g6; out[7] = f7 + g7; | ||
919 | } | ||
920 | return (w+5); | ||
921 | } | ||
922 | |||
923 | t_int *scalarplus_perform(t_int *w) | ||
924 | { | ||
925 | t_sample *in = (t_sample *)(w[1]); | ||
926 | t_sample f = ftofix(*(t_float *)(w[2])); | ||
927 | t_sample *out = (t_sample *)(w[3]); | ||
928 | int n = (int)(w[4]); | ||
929 | while (n--) *out++ = *in++ + f; | ||
930 | return (w+5); | ||
931 | } | ||
932 | |||
933 | t_int *scalarplus_perf8(t_int *w) | ||
934 | { | ||
935 | t_sample *in = (t_sample *)(w[1]); | ||
936 | t_sample g = ftofix(*(t_float *)(w[2])); | ||
937 | t_sample *out = (t_sample *)(w[3]); | ||
938 | int n = (int)(w[4]); | ||
939 | for (; n; n -= 8, in += 8, out += 8) | ||
940 | { | ||
941 | t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3]; | ||
942 | t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7]; | ||
943 | |||
944 | out[0] = f0 + g; out[1] = f1 + g; out[2] = f2 + g; out[3] = f3 + g; | ||
945 | out[4] = f4 + g; out[5] = f5 + g; out[6] = f6 + g; out[7] = f7 + g; | ||
946 | } | ||
947 | return (w+5); | ||
948 | } | ||
949 | |||
950 | void dsp_add_plus(t_sample *in1, t_sample *in2, t_sample *out, int n) | ||
951 | { | ||
952 | if (n&7) | ||
953 | dsp_add(plus_perform, 4, in1, in2, out, n); | ||
954 | else | ||
955 | dsp_add(plus_perf8, 4, in1, in2, out, n); | ||
956 | } | ||
957 | |||
958 | static void plus_dsp(t_plus *x, t_signal **sp) | ||
959 | { | ||
960 | dsp_add_plus(sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
961 | } | ||
962 | |||
963 | static void scalarplus_dsp(t_scalarplus *x, t_signal **sp) | ||
964 | { | ||
965 | if (sp[0]->s_n&7) | ||
966 | dsp_add(scalarplus_perform, 4, sp[0]->s_vec, &x->x_g, | ||
967 | sp[1]->s_vec, sp[0]->s_n); | ||
968 | else | ||
969 | dsp_add(scalarplus_perf8, 4, sp[0]->s_vec, &x->x_g, | ||
970 | sp[1]->s_vec, sp[0]->s_n); | ||
971 | } | ||
972 | |||
973 | static void plus_setup(void) | ||
974 | { | ||
975 | plus_class = class_new(gensym("+~"), (t_newmethod)plus_new, 0, | ||
976 | sizeof(t_plus), 0, A_GIMME, 0); | ||
977 | class_addmethod(plus_class, (t_method)plus_dsp, gensym("dsp"), 0); | ||
978 | CLASS_MAINSIGNALIN(plus_class, t_plus, x_f); | ||
979 | class_sethelpsymbol(plus_class, gensym("sigbinops")); | ||
980 | scalarplus_class = class_new(gensym("+~"), 0, 0, | ||
981 | sizeof(t_scalarplus), 0, 0); | ||
982 | CLASS_MAINSIGNALIN(scalarplus_class, t_scalarplus, x_f); | ||
983 | class_addmethod(scalarplus_class, (t_method)scalarplus_dsp, gensym("dsp"), | ||
984 | 0); | ||
985 | class_sethelpsymbol(scalarplus_class, gensym("sigbinops")); | ||
986 | } | ||
987 | |||
988 | /* ----------------------------- minus ----------------------------- */ | ||
989 | static t_class *minus_class, *scalarminus_class; | ||
990 | |||
991 | typedef struct _minus | ||
992 | { | ||
993 | t_object x_obj; | ||
994 | float x_f; | ||
995 | } t_minus; | ||
996 | |||
997 | typedef struct _scalarminus | ||
998 | { | ||
999 | t_object x_obj; | ||
1000 | float x_f; | ||
1001 | t_float x_g; | ||
1002 | } t_scalarminus; | ||
1003 | |||
1004 | static void *minus_new(t_symbol *s, int argc, t_atom *argv) | ||
1005 | { | ||
1006 | if (argc > 1) post("-~: extra arguments ignored"); | ||
1007 | if (argc) | ||
1008 | { | ||
1009 | t_scalarminus *x = (t_scalarminus *)pd_new(scalarminus_class); | ||
1010 | floatinlet_new(&x->x_obj, &x->x_g); | ||
1011 | x->x_g = atom_getfloatarg(0, argc, argv); | ||
1012 | outlet_new(&x->x_obj, &s_signal); | ||
1013 | x->x_f = 0; | ||
1014 | return (x); | ||
1015 | } | ||
1016 | else | ||
1017 | { | ||
1018 | t_minus *x = (t_minus *)pd_new(minus_class); | ||
1019 | inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); | ||
1020 | outlet_new(&x->x_obj, &s_signal); | ||
1021 | x->x_f = 0; | ||
1022 | return (x); | ||
1023 | } | ||
1024 | } | ||
1025 | |||
1026 | t_int *minus_perform(t_int *w) | ||
1027 | { | ||
1028 | t_sample *in1 = (t_sample *)(w[1]); | ||
1029 | t_sample *in2 = (t_sample *)(w[2]); | ||
1030 | t_sample *out = (t_sample *)(w[3]); | ||
1031 | int n = (int)(w[4]); | ||
1032 | while (n--) *out++ = *in1++ - *in2++; | ||
1033 | return (w+5); | ||
1034 | } | ||
1035 | |||
1036 | t_int *minus_perf8(t_int *w) | ||
1037 | { | ||
1038 | t_sample *in1 = (t_sample *)(w[1]); | ||
1039 | t_sample *in2 = (t_sample *)(w[2]); | ||
1040 | t_sample *out = (t_sample *)(w[3]); | ||
1041 | int n = (int)(w[4]); | ||
1042 | for (; n; n -= 8, in1 += 8, in2 += 8, out += 8) | ||
1043 | { | ||
1044 | t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3]; | ||
1045 | t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7]; | ||
1046 | |||
1047 | t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3]; | ||
1048 | t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7]; | ||
1049 | |||
1050 | out[0] = f0 - g0; out[1] = f1 - g1; out[2] = f2 - g2; out[3] = f3 - g3; | ||
1051 | out[4] = f4 - g4; out[5] = f5 - g5; out[6] = f6 - g6; out[7] = f7 - g7; | ||
1052 | } | ||
1053 | return (w+5); | ||
1054 | } | ||
1055 | |||
1056 | t_int *scalarminus_perform(t_int *w) | ||
1057 | { | ||
1058 | t_sample *in = (t_sample *)(w[1]); | ||
1059 | t_sample f = ftofix(*(t_float *)(w[2])); | ||
1060 | t_sample *out = (t_sample *)(w[3]); | ||
1061 | int n = (int)(w[4]); | ||
1062 | while (n--) *out++ = *in++ - f; | ||
1063 | return (w+5); | ||
1064 | } | ||
1065 | |||
1066 | t_int *scalarminus_perf8(t_int *w) | ||
1067 | { | ||
1068 | t_sample *in = (t_sample *)(w[1]); | ||
1069 | t_sample g = ftofix(*(t_float *)(w[2])); | ||
1070 | t_sample *out = (t_sample *)(w[3]); | ||
1071 | int n = (int)(w[4]); | ||
1072 | for (; n; n -= 8, in += 8, out += 8) | ||
1073 | { | ||
1074 | t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3]; | ||
1075 | t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7]; | ||
1076 | |||
1077 | out[0] = f0 - g; out[1] = f1 - g; out[2] = f2 - g; out[3] = f3 - g; | ||
1078 | out[4] = f4 - g; out[5] = f5 - g; out[6] = f6 - g; out[7] = f7 - g; | ||
1079 | } | ||
1080 | return (w+5); | ||
1081 | } | ||
1082 | |||
1083 | static void minus_dsp(t_minus *x, t_signal **sp) | ||
1084 | { | ||
1085 | if (sp[0]->s_n&7) | ||
1086 | dsp_add(minus_perform, 4, | ||
1087 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1088 | else | ||
1089 | dsp_add(minus_perf8, 4, | ||
1090 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1091 | } | ||
1092 | |||
1093 | static void scalarminus_dsp(t_scalarminus *x, t_signal **sp) | ||
1094 | { | ||
1095 | if (sp[0]->s_n&7) | ||
1096 | dsp_add(scalarminus_perform, 4, sp[0]->s_vec, &x->x_g, | ||
1097 | sp[1]->s_vec, sp[0]->s_n); | ||
1098 | else | ||
1099 | dsp_add(scalarminus_perf8, 4, sp[0]->s_vec, &x->x_g, | ||
1100 | sp[1]->s_vec, sp[0]->s_n); | ||
1101 | } | ||
1102 | |||
1103 | static void minus_setup(void) | ||
1104 | { | ||
1105 | minus_class = class_new(gensym("-~"), (t_newmethod)minus_new, 0, | ||
1106 | sizeof(t_minus), 0, A_GIMME, 0); | ||
1107 | CLASS_MAINSIGNALIN(minus_class, t_minus, x_f); | ||
1108 | class_addmethod(minus_class, (t_method)minus_dsp, gensym("dsp"), 0); | ||
1109 | class_sethelpsymbol(minus_class, gensym("sigbinops")); | ||
1110 | scalarminus_class = class_new(gensym("-~"), 0, 0, | ||
1111 | sizeof(t_scalarminus), 0, 0); | ||
1112 | CLASS_MAINSIGNALIN(scalarminus_class, t_scalarminus, x_f); | ||
1113 | class_addmethod(scalarminus_class, (t_method)scalarminus_dsp, gensym("dsp"), | ||
1114 | 0); | ||
1115 | class_sethelpsymbol(scalarminus_class, gensym("sigbinops")); | ||
1116 | } | ||
1117 | |||
1118 | /* ----------------------------- times ----------------------------- */ | ||
1119 | |||
1120 | static t_class *times_class, *scalartimes_class; | ||
1121 | |||
1122 | typedef struct _times | ||
1123 | { | ||
1124 | t_object x_obj; | ||
1125 | float x_f; | ||
1126 | } t_times; | ||
1127 | |||
1128 | typedef struct _scalartimes | ||
1129 | { | ||
1130 | t_object x_obj; | ||
1131 | float x_f; | ||
1132 | t_float x_g; | ||
1133 | } t_scalartimes; | ||
1134 | |||
1135 | static void *times_new(t_symbol *s, int argc, t_atom *argv) | ||
1136 | { | ||
1137 | if (argc > 1) post("*~: extra arguments ignored"); | ||
1138 | if (argc) | ||
1139 | { | ||
1140 | t_scalartimes *x = (t_scalartimes *)pd_new(scalartimes_class); | ||
1141 | floatinlet_new(&x->x_obj, &x->x_g); | ||
1142 | x->x_g = atom_getfloatarg(0, argc, argv); | ||
1143 | outlet_new(&x->x_obj, &s_signal); | ||
1144 | x->x_f = 0; | ||
1145 | return (x); | ||
1146 | } | ||
1147 | else | ||
1148 | { | ||
1149 | t_times *x = (t_times *)pd_new(times_class); | ||
1150 | inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); | ||
1151 | outlet_new(&x->x_obj, &s_signal); | ||
1152 | x->x_f = 0; | ||
1153 | return (x); | ||
1154 | } | ||
1155 | } | ||
1156 | |||
1157 | t_int *times_perform(t_int *w) | ||
1158 | { | ||
1159 | t_sample *in1 = (t_sample *)(w[1]); | ||
1160 | t_sample *in2 = (t_sample *)(w[2]); | ||
1161 | t_sample *out = (t_sample *)(w[3]); | ||
1162 | int n = (int)(w[4]); | ||
1163 | while (n--) *out++ = mult(*in1++,*in2++); | ||
1164 | return (w+5); | ||
1165 | } | ||
1166 | |||
1167 | t_int *times_perf8(t_int *w) | ||
1168 | { | ||
1169 | t_sample *in1 = (t_sample *)(w[1]); | ||
1170 | t_sample *in2 = (t_sample *)(w[2]); | ||
1171 | t_sample *out = (t_sample *)(w[3]); | ||
1172 | int n = (int)(w[4]); | ||
1173 | for (; n; n -= 8, in1 += 8, in2 += 8, out += 8) | ||
1174 | { | ||
1175 | t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3]; | ||
1176 | t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7]; | ||
1177 | |||
1178 | t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3]; | ||
1179 | t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7]; | ||
1180 | |||
1181 | out[0] = mult(f0,g0); out[1] = mult(f1,g1); out[2] = mult(f2,g2); out[3] = mult(f3,g3); | ||
1182 | out[4] = mult(f4,g4); out[5] = mult(f5,g5); out[6] = mult(f6,g6); out[7] = mult(f7,g7); | ||
1183 | } | ||
1184 | return (w+5); | ||
1185 | } | ||
1186 | |||
1187 | t_int *scalartimes_perform(t_int *w) | ||
1188 | { | ||
1189 | t_sample *in = (t_sample *)(w[1]); | ||
1190 | t_sample f = ftofix(*(t_float *)(w[2])); | ||
1191 | t_sample *out = (t_sample *)(w[3]); | ||
1192 | int n = (int)(w[4]); | ||
1193 | while (n--) *out++ = mult(*in++,f); | ||
1194 | return (w+5); | ||
1195 | } | ||
1196 | |||
1197 | t_int *scalartimes_perf8(t_int *w) | ||
1198 | { | ||
1199 | t_sample *in = (t_sample *)(w[1]); | ||
1200 | t_sample g = ftofix(*(t_float *)(w[2])); | ||
1201 | t_sample *out = (t_sample *)(w[3]); | ||
1202 | int n = (int)(w[4]); | ||
1203 | for (; n; n -= 8, in += 8, out += 8) | ||
1204 | { | ||
1205 | t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3]; | ||
1206 | t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7]; | ||
1207 | |||
1208 | out[0] = mult(f0,g); out[1] = mult(f1,g); out[2] = mult(f2,g); out[3] = mult(f3,g); | ||
1209 | out[4] = mult(f4,g); out[5] = mult(f5,g); out[6] = mult(f6,g); out[7] = mult(f7,g); | ||
1210 | } | ||
1211 | return (w+5); | ||
1212 | } | ||
1213 | |||
1214 | static void times_dsp(t_times *x, t_signal **sp) | ||
1215 | { | ||
1216 | if (sp[0]->s_n&7) | ||
1217 | dsp_add(times_perform, 4, | ||
1218 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1219 | else | ||
1220 | dsp_add(times_perf8, 4, | ||
1221 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1222 | } | ||
1223 | |||
1224 | static void scalartimes_dsp(t_scalartimes *x, t_signal **sp) | ||
1225 | { | ||
1226 | if (sp[0]->s_n&7) | ||
1227 | dsp_add(scalartimes_perform, 4, sp[0]->s_vec, &x->x_g, | ||
1228 | sp[1]->s_vec, sp[0]->s_n); | ||
1229 | else | ||
1230 | dsp_add(scalartimes_perf8, 4, sp[0]->s_vec, &x->x_g, | ||
1231 | sp[1]->s_vec, sp[0]->s_n); | ||
1232 | } | ||
1233 | |||
1234 | static void times_setup(void) | ||
1235 | { | ||
1236 | times_class = class_new(gensym("*~"), (t_newmethod)times_new, 0, | ||
1237 | sizeof(t_times), 0, A_GIMME, 0); | ||
1238 | CLASS_MAINSIGNALIN(times_class, t_times, x_f); | ||
1239 | class_addmethod(times_class, (t_method)times_dsp, gensym("dsp"), 0); | ||
1240 | class_sethelpsymbol(times_class, gensym("sigbinops")); | ||
1241 | scalartimes_class = class_new(gensym("*~"), 0, 0, | ||
1242 | sizeof(t_scalartimes), 0, 0); | ||
1243 | CLASS_MAINSIGNALIN(scalartimes_class, t_scalartimes, x_f); | ||
1244 | class_addmethod(scalartimes_class, (t_method)scalartimes_dsp, gensym("dsp"), | ||
1245 | 0); | ||
1246 | class_sethelpsymbol(scalartimes_class, gensym("sigbinops")); | ||
1247 | } | ||
1248 | |||
1249 | /* ----------------------------- over ----------------------------- */ | ||
1250 | static t_class *over_class, *scalarover_class; | ||
1251 | |||
1252 | typedef struct _over | ||
1253 | { | ||
1254 | t_object x_obj; | ||
1255 | float x_f; | ||
1256 | } t_over; | ||
1257 | |||
1258 | typedef struct _scalarover | ||
1259 | { | ||
1260 | t_object x_obj; | ||
1261 | float x_f; | ||
1262 | t_float x_g; | ||
1263 | } t_scalarover; | ||
1264 | |||
1265 | static void *over_new(t_symbol *s, int argc, t_atom *argv) | ||
1266 | { | ||
1267 | if (argc > 1) post("/~: extra arguments ignored"); | ||
1268 | if (argc) | ||
1269 | { | ||
1270 | t_scalarover *x = (t_scalarover *)pd_new(scalarover_class); | ||
1271 | floatinlet_new(&x->x_obj, &x->x_g); | ||
1272 | x->x_g = atom_getfloatarg(0, argc, argv); | ||
1273 | outlet_new(&x->x_obj, &s_signal); | ||
1274 | x->x_f = 0; | ||
1275 | return (x); | ||
1276 | } | ||
1277 | else | ||
1278 | { | ||
1279 | t_over *x = (t_over *)pd_new(over_class); | ||
1280 | inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); | ||
1281 | outlet_new(&x->x_obj, &s_signal); | ||
1282 | x->x_f = 0; | ||
1283 | return (x); | ||
1284 | } | ||
1285 | } | ||
1286 | |||
1287 | t_int *over_perform(t_int *w) | ||
1288 | { | ||
1289 | t_sample *in1 = (t_sample *)(w[1]); | ||
1290 | t_sample *in2 = (t_sample *)(w[2]); | ||
1291 | t_sample *out = (t_sample *)(w[3]); | ||
1292 | int n = (int)(w[4]); | ||
1293 | while (n--) | ||
1294 | { | ||
1295 | float g = *in2++; | ||
1296 | *out++ = (g ? *in1++ / g : 0); | ||
1297 | } | ||
1298 | return (w+5); | ||
1299 | } | ||
1300 | |||
1301 | t_int *over_perf8(t_int *w) | ||
1302 | { | ||
1303 | t_sample *in1 = (t_sample *)(w[1]); | ||
1304 | t_sample *in2 = (t_sample *)(w[2]); | ||
1305 | t_sample *out = (t_sample *)(w[3]); | ||
1306 | int n = (int)(w[4]); | ||
1307 | for (; n; n -= 8, in1 += 8, in2 += 8, out += 8) | ||
1308 | { | ||
1309 | t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3]; | ||
1310 | t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7]; | ||
1311 | |||
1312 | t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3]; | ||
1313 | t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7]; | ||
1314 | |||
1315 | out[0] = (g0? idiv(f0,g0) : 0); | ||
1316 | out[1] = (g1? idiv(f1,g1) : 0); | ||
1317 | out[2] = (g2? idiv(f2,g2) : 0); | ||
1318 | out[3] = (g3? idiv(f3,g3) : 0); | ||
1319 | out[4] = (g4? idiv(f4,g4) : 0); | ||
1320 | out[5] = (g5? idiv(f5,g5) : 0); | ||
1321 | out[6] = (g6? idiv(f6,g6) : 0); | ||
1322 | out[7] = (g7? idiv(f7,g7) : 0); | ||
1323 | } | ||
1324 | return (w+5); | ||
1325 | } | ||
1326 | |||
1327 | t_int *scalarover_perform(t_int *w) | ||
1328 | { | ||
1329 | t_sample *in = (t_sample *)(w[1]); | ||
1330 | t_sample f = idiv(ftofix(1.),ftofix(*(t_float *)(w[2]))); | ||
1331 | t_sample *out = (t_sample *)(w[3]); | ||
1332 | int n = (int)(w[4]); | ||
1333 | while (n--) *out++ = mult(*in++,f); | ||
1334 | return (w+5); | ||
1335 | } | ||
1336 | |||
1337 | t_int *scalarover_perf8(t_int *w) | ||
1338 | { | ||
1339 | t_sample *in = (t_sample *)(w[1]); | ||
1340 | t_sample g = ftofix(*(t_float *)(w[2])); | ||
1341 | t_sample *out = (t_sample *)(w[3]); | ||
1342 | int n = (int)(w[4]); | ||
1343 | if (g) g = idiv(ftofix(1.f),g); | ||
1344 | for (; n; n -= 8, in += 8, out += 8) | ||
1345 | { | ||
1346 | t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3]; | ||
1347 | t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7]; | ||
1348 | |||
1349 | out[0] = mult(f0,g); out[1] = mult(f1,g); out[2] = mult(f2,g); out[3] = mult(f3,g); | ||
1350 | out[4] = mult(f4,g); out[5] = mult(f5,g); out[6] = mult(f6,g); out[7] = mult(f7,g); | ||
1351 | } | ||
1352 | return (w+5); | ||
1353 | } | ||
1354 | |||
1355 | static void over_dsp(t_over *x, t_signal **sp) | ||
1356 | { | ||
1357 | if (sp[0]->s_n&7) | ||
1358 | dsp_add(over_perform, 4, | ||
1359 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1360 | else | ||
1361 | dsp_add(over_perf8, 4, | ||
1362 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1363 | } | ||
1364 | |||
1365 | static void scalarover_dsp(t_scalarover *x, t_signal **sp) | ||
1366 | { | ||
1367 | if (sp[0]->s_n&7) | ||
1368 | dsp_add(scalarover_perform, 4, sp[0]->s_vec, &x->x_g, | ||
1369 | sp[1]->s_vec, sp[0]->s_n); | ||
1370 | else | ||
1371 | dsp_add(scalarover_perf8, 4, sp[0]->s_vec, &x->x_g, | ||
1372 | sp[1]->s_vec, sp[0]->s_n); | ||
1373 | } | ||
1374 | |||
1375 | static void over_setup(void) | ||
1376 | { | ||
1377 | over_class = class_new(gensym("/~"), (t_newmethod)over_new, 0, | ||
1378 | sizeof(t_over), 0, A_GIMME, 0); | ||
1379 | CLASS_MAINSIGNALIN(over_class, t_over, x_f); | ||
1380 | class_addmethod(over_class, (t_method)over_dsp, gensym("dsp"), 0); | ||
1381 | class_sethelpsymbol(over_class, gensym("sigbinops")); | ||
1382 | scalarover_class = class_new(gensym("/~"), 0, 0, | ||
1383 | sizeof(t_scalarover), 0, 0); | ||
1384 | CLASS_MAINSIGNALIN(scalarover_class, t_scalarover, x_f); | ||
1385 | class_addmethod(scalarover_class, (t_method)scalarover_dsp, gensym("dsp"), | ||
1386 | 0); | ||
1387 | class_sethelpsymbol(scalarover_class, gensym("sigbinops")); | ||
1388 | } | ||
1389 | |||
1390 | /* ----------------------------- max ----------------------------- */ | ||
1391 | static t_class *max_class, *scalarmax_class; | ||
1392 | |||
1393 | typedef struct _max | ||
1394 | { | ||
1395 | t_object x_obj; | ||
1396 | float x_f; | ||
1397 | } t_max; | ||
1398 | |||
1399 | typedef struct _scalarmax | ||
1400 | { | ||
1401 | t_object x_obj; | ||
1402 | float x_f; | ||
1403 | t_float x_g; | ||
1404 | } t_scalarmax; | ||
1405 | |||
1406 | static void *max_new(t_symbol *s, int argc, t_atom *argv) | ||
1407 | { | ||
1408 | if (argc > 1) post("max~: extra arguments ignored"); | ||
1409 | if (argc) | ||
1410 | { | ||
1411 | t_scalarmax *x = (t_scalarmax *)pd_new(scalarmax_class); | ||
1412 | floatinlet_new(&x->x_obj, &x->x_g); | ||
1413 | x->x_g = atom_getfloatarg(0, argc, argv); | ||
1414 | outlet_new(&x->x_obj, &s_signal); | ||
1415 | x->x_f = 0; | ||
1416 | return (x); | ||
1417 | } | ||
1418 | else | ||
1419 | { | ||
1420 | t_max *x = (t_max *)pd_new(max_class); | ||
1421 | inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); | ||
1422 | outlet_new(&x->x_obj, &s_signal); | ||
1423 | x->x_f = 0; | ||
1424 | return (x); | ||
1425 | } | ||
1426 | } | ||
1427 | |||
1428 | t_int *max_perform(t_int *w) | ||
1429 | { | ||
1430 | t_sample *in1 = (t_sample *)(w[1]); | ||
1431 | t_sample *in2 = (t_sample *)(w[2]); | ||
1432 | t_sample *out = (t_sample *)(w[3]); | ||
1433 | int n = (int)(w[4]); | ||
1434 | while (n--) | ||
1435 | { | ||
1436 | t_sample f = *in1++, g = *in2++; | ||
1437 | *out++ = (f > g ? f : g); | ||
1438 | } | ||
1439 | return (w+5); | ||
1440 | } | ||
1441 | |||
1442 | t_int *max_perf8(t_int *w) | ||
1443 | { | ||
1444 | t_sample *in1 = (t_sample *)(w[1]); | ||
1445 | t_sample *in2 = (t_sample *)(w[2]); | ||
1446 | t_sample *out = (t_sample *)(w[3]); | ||
1447 | int n = (int)(w[4]); | ||
1448 | for (; n; n -= 8, in1 += 8, in2 += 8, out += 8) | ||
1449 | { | ||
1450 | t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3]; | ||
1451 | t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7]; | ||
1452 | |||
1453 | t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3]; | ||
1454 | t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7]; | ||
1455 | |||
1456 | out[0] = (f0 > g0 ? f0 : g0); out[1] = (f1 > g1 ? f1 : g1); | ||
1457 | out[2] = (f2 > g2 ? f2 : g2); out[3] = (f3 > g3 ? f3 : g3); | ||
1458 | out[4] = (f4 > g4 ? f4 : g4); out[5] = (f5 > g5 ? f5 : g5); | ||
1459 | out[6] = (f6 > g6 ? f6 : g6); out[7] = (f7 > g7 ? f7 : g7); | ||
1460 | } | ||
1461 | return (w+5); | ||
1462 | } | ||
1463 | |||
1464 | t_int *scalarmax_perform(t_int *w) | ||
1465 | { | ||
1466 | t_sample *in = (t_sample *)(w[1]); | ||
1467 | t_sample f = ftofix(*(t_float *)(w[2])); | ||
1468 | t_sample *out = (t_sample *)(w[3]); | ||
1469 | int n = (int)(w[4]); | ||
1470 | while (n--) | ||
1471 | { | ||
1472 | t_sample g = *in++; | ||
1473 | *out++ = (f > g ? f : g); | ||
1474 | } | ||
1475 | return (w+5); | ||
1476 | } | ||
1477 | |||
1478 | t_int *scalarmax_perf8(t_int *w) | ||
1479 | { | ||
1480 | t_sample *in = (t_sample *)(w[1]); | ||
1481 | t_sample g = ftofix(*(t_float *)(w[2])); | ||
1482 | t_sample *out = (t_sample *)(w[3]); | ||
1483 | int n = (int)(w[4]); | ||
1484 | for (; n; n -= 8, in += 8, out += 8) | ||
1485 | { | ||
1486 | t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3]; | ||
1487 | t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7]; | ||
1488 | |||
1489 | out[0] = (f0 > g ? f0 : g); out[1] = (f1 > g ? f1 : g); | ||
1490 | out[2] = (f2 > g ? f2 : g); out[3] = (f3 > g ? f3 : g); | ||
1491 | out[4] = (f4 > g ? f4 : g); out[5] = (f5 > g ? f5 : g); | ||
1492 | out[6] = (f6 > g ? f6 : g); out[7] = (f7 > g ? f7 : g); | ||
1493 | } | ||
1494 | return (w+5); | ||
1495 | } | ||
1496 | |||
1497 | static void max_dsp(t_max *x, t_signal **sp) | ||
1498 | { | ||
1499 | if (sp[0]->s_n&7) | ||
1500 | dsp_add(max_perform, 4, | ||
1501 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1502 | else | ||
1503 | dsp_add(max_perf8, 4, | ||
1504 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1505 | } | ||
1506 | |||
1507 | static void scalarmax_dsp(t_scalarmax *x, t_signal **sp) | ||
1508 | { | ||
1509 | if (sp[0]->s_n&7) | ||
1510 | dsp_add(scalarmax_perform, 4, sp[0]->s_vec, &x->x_g, | ||
1511 | sp[1]->s_vec, sp[0]->s_n); | ||
1512 | else | ||
1513 | dsp_add(scalarmax_perf8, 4, sp[0]->s_vec, &x->x_g, | ||
1514 | sp[1]->s_vec, sp[0]->s_n); | ||
1515 | } | ||
1516 | |||
1517 | static void max_setup(void) | ||
1518 | { | ||
1519 | max_class = class_new(gensym("max~"), (t_newmethod)max_new, 0, | ||
1520 | sizeof(t_max), 0, A_GIMME, 0); | ||
1521 | CLASS_MAINSIGNALIN(max_class, t_max, x_f); | ||
1522 | class_addmethod(max_class, (t_method)max_dsp, gensym("dsp"), 0); | ||
1523 | class_sethelpsymbol(max_class, gensym("sigbinops")); | ||
1524 | scalarmax_class = class_new(gensym("max~"), 0, 0, | ||
1525 | sizeof(t_scalarmax), 0, 0); | ||
1526 | CLASS_MAINSIGNALIN(scalarmax_class, t_scalarmax, x_f); | ||
1527 | class_addmethod(scalarmax_class, (t_method)scalarmax_dsp, gensym("dsp"), | ||
1528 | 0); | ||
1529 | class_sethelpsymbol(scalarmax_class, gensym("sigbinops")); | ||
1530 | } | ||
1531 | |||
1532 | /* ----------------------------- min ----------------------------- */ | ||
1533 | static t_class *min_class, *scalarmin_class; | ||
1534 | |||
1535 | typedef struct _min | ||
1536 | { | ||
1537 | t_object x_obj; | ||
1538 | float x_f; | ||
1539 | } t_min; | ||
1540 | |||
1541 | typedef struct _scalarmin | ||
1542 | { | ||
1543 | t_object x_obj; | ||
1544 | t_float x_g; | ||
1545 | float x_f; | ||
1546 | } t_scalarmin; | ||
1547 | |||
1548 | static void *min_new(t_symbol *s, int argc, t_atom *argv) | ||
1549 | { | ||
1550 | if (argc > 1) post("min~: extra arguments ignored"); | ||
1551 | if (argc) | ||
1552 | { | ||
1553 | t_scalarmin *x = (t_scalarmin *)pd_new(scalarmin_class); | ||
1554 | floatinlet_new(&x->x_obj, &x->x_g); | ||
1555 | x->x_g = atom_getfloatarg(0, argc, argv); | ||
1556 | outlet_new(&x->x_obj, &s_signal); | ||
1557 | x->x_f = 0; | ||
1558 | return (x); | ||
1559 | } | ||
1560 | else | ||
1561 | { | ||
1562 | t_min *x = (t_min *)pd_new(min_class); | ||
1563 | inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal); | ||
1564 | outlet_new(&x->x_obj, &s_signal); | ||
1565 | x->x_f = 0; | ||
1566 | return (x); | ||
1567 | } | ||
1568 | } | ||
1569 | |||
1570 | t_int *min_perform(t_int *w) | ||
1571 | { | ||
1572 | t_sample *in1 = (t_sample *)(w[1]); | ||
1573 | t_sample *in2 = (t_sample *)(w[2]); | ||
1574 | t_sample *out = (t_sample *)(w[3]); | ||
1575 | int n = (int)(w[4]); | ||
1576 | while (n--) | ||
1577 | { | ||
1578 | t_sample f = *in1++, g = *in2++; | ||
1579 | *out++ = (f < g ? f : g); | ||
1580 | } | ||
1581 | return (w+5); | ||
1582 | } | ||
1583 | |||
1584 | t_int *min_perf8(t_int *w) | ||
1585 | { | ||
1586 | t_sample *in1 = (t_sample *)(w[1]); | ||
1587 | t_sample *in2 = (t_sample *)(w[2]); | ||
1588 | t_sample *out = (t_sample *)(w[3]); | ||
1589 | int n = (int)(w[4]); | ||
1590 | for (; n; n -= 8, in1 += 8, in2 += 8, out += 8) | ||
1591 | { | ||
1592 | t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3]; | ||
1593 | t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7]; | ||
1594 | |||
1595 | t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3]; | ||
1596 | t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7]; | ||
1597 | |||
1598 | out[0] = (f0 < g0 ? f0 : g0); out[1] = (f1 < g1 ? f1 : g1); | ||
1599 | out[2] = (f2 < g2 ? f2 : g2); out[3] = (f3 < g3 ? f3 : g3); | ||
1600 | out[4] = (f4 < g4 ? f4 : g4); out[5] = (f5 < g5 ? f5 : g5); | ||
1601 | out[6] = (f6 < g6 ? f6 : g6); out[7] = (f7 < g7 ? f7 : g7); | ||
1602 | } | ||
1603 | return (w+5); | ||
1604 | } | ||
1605 | |||
1606 | t_int *scalarmin_perform(t_int *w) | ||
1607 | { | ||
1608 | t_sample *in = (t_sample *)(w[1]); | ||
1609 | t_sample f = ftofix(*(t_float *)(w[2])); | ||
1610 | t_sample *out = (t_sample *)(w[3]); | ||
1611 | int n = (int)(w[4]); | ||
1612 | while (n--) | ||
1613 | { | ||
1614 | t_sample g = *in++; | ||
1615 | *out++ = (f < g ? f : g); | ||
1616 | } | ||
1617 | return (w+5); | ||
1618 | } | ||
1619 | |||
1620 | t_int *scalarmin_perf8(t_int *w) | ||
1621 | { | ||
1622 | t_sample *in = (t_sample *)(w[1]); | ||
1623 | t_sample g = ftofix(*(t_float *)(w[2])); | ||
1624 | t_sample *out = (t_sample *)(w[3]); | ||
1625 | int n = (int)(w[4]); | ||
1626 | for (; n; n -= 8, in += 8, out += 8) | ||
1627 | { | ||
1628 | t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3]; | ||
1629 | t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7]; | ||
1630 | |||
1631 | out[0] = (f0 < g ? f0 : g); out[1] = (f1 < g ? f1 : g); | ||
1632 | out[2] = (f2 < g ? f2 : g); out[3] = (f3 < g ? f3 : g); | ||
1633 | out[4] = (f4 < g ? f4 : g); out[5] = (f5 < g ? f5 : g); | ||
1634 | out[6] = (f6 < g ? f6 : g); out[7] = (f7 < g ? f7 : g); | ||
1635 | } | ||
1636 | return (w+5); | ||
1637 | } | ||
1638 | |||
1639 | static void min_dsp(t_min *x, t_signal **sp) | ||
1640 | { | ||
1641 | if (sp[0]->s_n&7) | ||
1642 | dsp_add(min_perform, 4, | ||
1643 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1644 | else | ||
1645 | dsp_add(min_perf8, 4, | ||
1646 | sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n); | ||
1647 | } | ||
1648 | |||
1649 | static void scalarmin_dsp(t_scalarmin *x, t_signal **sp) | ||
1650 | { | ||
1651 | if (sp[0]->s_n&7) | ||
1652 | dsp_add(scalarmin_perform, 4, sp[0]->s_vec, &x->x_g, | ||
1653 | sp[1]->s_vec, sp[0]->s_n); | ||
1654 | else | ||
1655 | dsp_add(scalarmin_perf8, 4, sp[0]->s_vec, &x->x_g, | ||
1656 | sp[1]->s_vec, sp[0]->s_n); | ||
1657 | } | ||
1658 | |||
1659 | static void min_setup(void) | ||
1660 | { | ||
1661 | min_class = class_new(gensym("min~"), (t_newmethod)min_new, 0, | ||
1662 | sizeof(t_min), 0, A_GIMME, 0); | ||
1663 | CLASS_MAINSIGNALIN(min_class, t_min, x_f); | ||
1664 | class_addmethod(min_class, (t_method)min_dsp, gensym("dsp"), 0); | ||
1665 | class_sethelpsymbol(min_class, gensym("sigbinops")); | ||
1666 | scalarmin_class = class_new(gensym("min~"), 0, 0, | ||
1667 | sizeof(t_scalarmin), 0, 0); | ||
1668 | CLASS_MAINSIGNALIN(scalarmin_class, t_scalarmin, x_f); | ||
1669 | class_addmethod(scalarmin_class, (t_method)scalarmin_dsp, gensym("dsp"), | ||
1670 | 0); | ||
1671 | class_sethelpsymbol(scalarmin_class, gensym("sigbinops")); | ||
1672 | } | ||
1673 | |||
1674 | /* ----------------------- global setup routine ---------------- */ | ||
1675 | void d_arithmetic_setup(void) | ||
1676 | { | ||
1677 | plus_setup(); | ||
1678 | minus_setup(); | ||
1679 | times_setup(); | ||
1680 | over_setup(); | ||
1681 | max_setup(); | ||
1682 | min_setup(); | ||
1683 | } | ||
1684 | |||