alice.mosphere.at / TIC-80
this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

GPT5-high pass 5: spectral whitening pt3 bindings etc.

alice 34dc89f8 1fa0a86b

+475 -14
+49
src/api.h
··· 913 913 tic_mem*, s32 bin) \ 914 914 \ 915 915 \ 916 + macro(vqtw, \ 917 + "vqtw(bin)", \ 918 + \ 919 + "Get peak-normalized whitened VQT magnitude for a bin.\n" \ 920 + "Whitening evens out the spectral envelope so notes stand out.\n" \ 921 + "Bin mapping: 0-119 (10 octaves × 12 notes).", \ 922 + 1, \ 923 + 1, \ 924 + 0, \ 925 + double, \ 926 + tic_mem*, s32 bin) \ 927 + \ 928 + \ 929 + macro(vqtsw, \ 930 + "vqtsw(bin)", \ 931 + \ 932 + "Get smoothed, peak-normalized whitened VQT magnitude for a bin.\n" \ 933 + "Useful for visuals with stable dynamics.", \ 934 + 1, \ 935 + 1, \ 936 + 0, \ 937 + double, \ 938 + tic_mem*, s32 bin) \ 939 + \ 940 + \ 941 + macro(vqtrw, \ 942 + "vqtrw(bin)", \ 943 + \ 944 + "Get raw (non-normalized) whitened VQT magnitude for a bin.\n" \ 945 + "Whitened but without peak auto-gain control.", \ 946 + 1, \ 947 + 1, \ 948 + 0, \ 949 + double, \ 950 + tic_mem*, s32 bin) \ 951 + \ 952 + \ 953 + macro(vqtrsw, \ 954 + "vqtrsw(bin)", \ 955 + \ 956 + "Get raw smoothed whitened VQT magnitude for a bin.\n" \ 957 + "Smoothed, without peak auto-gain control.", \ 958 + 1, \ 959 + 1, \ 960 + 0, \ 961 + double, \ 962 + tic_mem*, s32 bin) \ 963 + \ 964 + \ 916 965 917 966 918 967 #define TIC_API_DEF(name, _, __, ___, ____, _____, ret, ...) ret tic_api_##name(__VA_ARGS__);
+48
src/api/janet.c
··· 87 87 static Janet janet_fftrs(int32_t argc, Janet* argv); 88 88 static Janet janet_vqtr(int32_t argc, Janet* argv); 89 89 static Janet janet_vqtrs(int32_t argc, Janet* argv); 90 + static Janet janet_vqtw(int32_t argc, Janet* argv); 91 + static Janet janet_vqtsw(int32_t argc, Janet* argv); 92 + static Janet janet_vqtrw(int32_t argc, Janet* argv); 93 + static Janet janet_vqtrsw(int32_t argc, Janet* argv); 90 94 91 95 static void closeJanet(tic_mem* tic); 92 96 static bool initJanet(tic_mem* tic, const char* code); ··· 158 162 {"fftrs", janet_fftrs, NULL}, 159 163 {"vqtr", janet_vqtr, NULL}, 160 164 {"vqtrs", janet_vqtrs, NULL}, 165 + {"vqtw", janet_vqtw, NULL}, 166 + {"vqtsw", janet_vqtsw, NULL}, 167 + {"vqtrw", janet_vqtrw, NULL}, 168 + {"vqtrsw", janet_vqtrsw, NULL}, 161 169 {NULL, NULL, NULL} 162 170 }; 163 171 ··· 1156 1164 1157 1165 tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core; 1158 1166 return janet_wrap_number(core->api.vqtrs(tic, bin)); 1167 + } 1168 + 1169 + static Janet janet_vqtw(int32_t argc, Janet* argv) 1170 + { 1171 + janet_fixarity(argc, 1); 1172 + 1173 + s32 bin = janet_getinteger(argv, 0); 1174 + 1175 + tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core; 1176 + return janet_wrap_number(core->api.vqtw(tic, bin)); 1177 + } 1178 + 1179 + static Janet janet_vqtsw(int32_t argc, Janet* argv) 1180 + { 1181 + janet_fixarity(argc, 1); 1182 + 1183 + s32 bin = janet_getinteger(argv, 0); 1184 + 1185 + tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core; 1186 + return janet_wrap_number(core->api.vqtsw(tic, bin)); 1187 + } 1188 + 1189 + static Janet janet_vqtrw(int32_t argc, Janet* argv) 1190 + { 1191 + janet_fixarity(argc, 1); 1192 + 1193 + s32 bin = janet_getinteger(argv, 0); 1194 + 1195 + tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core; 1196 + return janet_wrap_number(core->api.vqtrw(tic, bin)); 1197 + } 1198 + 1199 + static Janet janet_vqtrsw(int32_t argc, Janet* argv) 1200 + { 1201 + janet_fixarity(argc, 1); 1202 + 1203 + s32 bin = janet_getinteger(argv, 0); 1204 + 1205 + tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core; 1206 + return janet_wrap_number(core->api.vqtrsw(tic, bin)); 1159 1207 } 1160 1208 1161 1209 /* ***************** */
+32
src/api/js.c
··· 1082 1082 return JS_NewFloat64(ctx, core->api.vqtrs(tic, bin)); 1083 1083 } 1084 1084 1085 + static JSValue js_vqtw(JSContext *ctx, JSValueConst this_val, s32 argc, JSValueConst *argv) 1086 + { 1087 + tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core; 1088 + s32 bin = getInteger(ctx, argv[0]); 1089 + 1090 + return JS_NewFloat64(ctx, core->api.vqtw(tic, bin)); 1091 + } 1092 + 1093 + static JSValue js_vqtsw(JSContext *ctx, JSValueConst this_val, s32 argc, JSValueConst *argv) 1094 + { 1095 + tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core; 1096 + s32 bin = getInteger(ctx, argv[0]); 1097 + 1098 + return JS_NewFloat64(ctx, core->api.vqtsw(tic, bin)); 1099 + } 1100 + 1101 + static JSValue js_vqtrw(JSContext *ctx, JSValueConst this_val, s32 argc, JSValueConst *argv) 1102 + { 1103 + tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core; 1104 + s32 bin = getInteger(ctx, argv[0]); 1105 + 1106 + return JS_NewFloat64(ctx, core->api.vqtrw(tic, bin)); 1107 + } 1108 + 1109 + static JSValue js_vqtrsw(JSContext *ctx, JSValueConst this_val, s32 argc, JSValueConst *argv) 1110 + { 1111 + tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core; 1112 + s32 bin = getInteger(ctx, argv[0]); 1113 + 1114 + return JS_NewFloat64(ctx, core->api.vqtrsw(tic, bin)); 1115 + } 1116 + 1085 1117 static bool initJavascript(tic_mem* tic, const char* code) 1086 1118 { 1087 1119 closeJavascript(tic);
+4 -12
src/api/luaapi.c
··· 1714 1714 if (top >= 1) 1715 1715 { 1716 1716 s32 bin = getLuaNumber(lua, 1); 1717 - extern double tic_api_vqtw(tic_mem*, s32); 1718 - lua_pushnumber(lua, tic_api_vqtw(tic, bin)); 1717 + lua_pushnumber(lua, core->api.vqtw(tic, bin)); 1719 1718 return 1; 1720 1719 } 1721 1720 ··· 1732 1731 if (top >= 1) 1733 1732 { 1734 1733 s32 bin = getLuaNumber(lua, 1); 1735 - extern double tic_api_vqtsw(tic_mem*, s32); 1736 - lua_pushnumber(lua, tic_api_vqtsw(tic, bin)); 1734 + lua_pushnumber(lua, core->api.vqtsw(tic, bin)); 1737 1735 return 1; 1738 1736 } 1739 1737 ··· 1750 1748 if (top >= 1) 1751 1749 { 1752 1750 s32 bin = getLuaNumber(lua, 1); 1753 - extern double tic_api_vqtrw(tic_mem*, s32); 1754 - lua_pushnumber(lua, tic_api_vqtrw(tic, bin)); 1751 + lua_pushnumber(lua, core->api.vqtrw(tic, bin)); 1755 1752 return 1; 1756 1753 } 1757 1754 ··· 1768 1765 if (top >= 1) 1769 1766 { 1770 1767 s32 bin = getLuaNumber(lua, 1); 1771 - extern double tic_api_vqtrsw(tic_mem*, s32); 1772 - lua_pushnumber(lua, tic_api_vqtrsw(tic, bin)); 1768 + lua_pushnumber(lua, core->api.vqtrsw(tic, bin)); 1773 1769 return 1; 1774 1770 } 1775 1771 ··· 1824 1820 #if defined(BUILD_DEPRECATED) 1825 1821 {(lua_CFunction)lua_textri, "textri"}, 1826 1822 #endif 1827 - {(lua_CFunction)lua_vqtw, "vqtw"}, 1828 - {(lua_CFunction)lua_vqtsw, "vqtsw"}, 1829 - {(lua_CFunction)lua_vqtrw, "vqtrw"}, 1830 - {(lua_CFunction)lua_vqtrsw, "vqtrsw"}, 1831 1823 }; 1832 1824 1833 1825 for (s32 i = 0; i < COUNT_OF(ApiItems); i++)
+76
src/api/mruby.c
··· 682 682 } 683 683 } 684 684 685 + static mrb_value mrb_vqtw(mrb_state* mrb, mrb_value self) 686 + { 687 + mrb_int bin; 688 + mrb_int argc = mrb_get_args(mrb, "i", &bin); 689 + 690 + tic_core* core = getMRubyMachine(mrb); 691 + tic_mem* tic = (tic_mem*)core; 692 + 693 + if (argc == 0) 694 + { 695 + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid params, vqtw(bin)\n"); 696 + return mrb_nil_value(); 697 + } 698 + else 699 + { 700 + return mrb_float_value(mrb, core->api.vqtw(tic, bin)); 701 + } 702 + } 703 + 704 + static mrb_value mrb_vqtsw(mrb_state* mrb, mrb_value self) 705 + { 706 + mrb_int bin; 707 + mrb_int argc = mrb_get_args(mrb, "i", &bin); 708 + 709 + tic_core* core = getMRubyMachine(mrb); 710 + tic_mem* tic = (tic_mem*)core; 711 + 712 + if (argc == 0) 713 + { 714 + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid params, vqtsw(bin)\n"); 715 + return mrb_nil_value(); 716 + } 717 + else 718 + { 719 + return mrb_float_value(mrb, core->api.vqtsw(tic, bin)); 720 + } 721 + } 722 + 723 + static mrb_value mrb_vqtrw(mrb_state* mrb, mrb_value self) 724 + { 725 + mrb_int bin; 726 + mrb_int argc = mrb_get_args(mrb, "i", &bin); 727 + 728 + tic_core* core = getMRubyMachine(mrb); 729 + tic_mem* tic = (tic_mem*)core; 730 + 731 + if (argc == 0) 732 + { 733 + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid params, vqtrw(bin)\n"); 734 + return mrb_nil_value(); 735 + } 736 + else 737 + { 738 + return mrb_float_value(mrb, core->api.vqtrw(tic, bin)); 739 + } 740 + } 741 + 742 + static mrb_value mrb_vqtrsw(mrb_state* mrb, mrb_value self) 743 + { 744 + mrb_int bin; 745 + mrb_int argc = mrb_get_args(mrb, "i", &bin); 746 + 747 + tic_core* core = getMRubyMachine(mrb); 748 + tic_mem* tic = (tic_mem*)core; 749 + 750 + if (argc == 0) 751 + { 752 + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid params, vqtrsw(bin)\n"); 753 + return mrb_nil_value(); 754 + } 755 + else 756 + { 757 + return mrb_float_value(mrb, core->api.vqtrsw(tic, bin)); 758 + } 759 + } 760 + 685 761 typedef struct 686 762 { 687 763 mrb_state* mrb;
+64
src/api/python.c
··· 1255 1255 return true; 1256 1256 } 1257 1257 1258 + static bool py_vqtw(int argc, py_Ref argv) 1259 + { 1260 + int bin; 1261 + PY_CHECK_ARG_TYPE(0, tp_int); 1262 + 1263 + tic_core* core = get_core(); 1264 + tic_mem* tic = (tic_mem*)core; 1265 + 1266 + bin = py_toint(py_arg(0)); 1267 + 1268 + double result = tic_api_vqtw(tic, bin); 1269 + py_newfloat(py_retval(), result); 1270 + return true; 1271 + } 1272 + 1273 + static bool py_vqtsw(int argc, py_Ref argv) 1274 + { 1275 + int bin; 1276 + PY_CHECK_ARG_TYPE(0, tp_int); 1277 + 1278 + tic_core* core = get_core(); 1279 + tic_mem* tic = (tic_mem*)core; 1280 + 1281 + bin = py_toint(py_arg(0)); 1282 + 1283 + double result = tic_api_vqtsw(tic, bin); 1284 + py_newfloat(py_retval(), result); 1285 + return true; 1286 + } 1287 + 1288 + static bool py_vqtrw(int argc, py_Ref argv) 1289 + { 1290 + int bin; 1291 + PY_CHECK_ARG_TYPE(0, tp_int); 1292 + 1293 + tic_core* core = get_core(); 1294 + tic_mem* tic = (tic_mem*)core; 1295 + 1296 + bin = py_toint(py_arg(0)); 1297 + 1298 + double result = tic_api_vqtrw(tic, bin); 1299 + py_newfloat(py_retval(), result); 1300 + return true; 1301 + } 1302 + 1303 + static bool py_vqtrsw(int argc, py_Ref argv) 1304 + { 1305 + int bin; 1306 + PY_CHECK_ARG_TYPE(0, tp_int); 1307 + 1308 + tic_core* core = get_core(); 1309 + tic_mem* tic = (tic_mem*)core; 1310 + 1311 + bin = py_toint(py_arg(0)); 1312 + 1313 + double result = tic_api_vqtrsw(tic, bin); 1314 + py_newfloat(py_retval(), result); 1315 + return true; 1316 + } 1317 + 1258 1318 static bool bind_pkpy_v2() 1259 1319 { 1260 1320 py_GlobalRef mod = py_getmodule("__main__"); ··· 1313 1373 py_bind(mod, "vqts(bin: int) -> float", py_vqts); 1314 1374 py_bind(mod, "vqtr(bin: int) -> float", py_vqtr); 1315 1375 py_bind(mod, "vqtrs(bin: int) -> float", py_vqtrs); 1376 + py_bind(mod, "vqtw(bin: int) -> float", py_vqtw); 1377 + py_bind(mod, "vqtsw(bin: int) -> float", py_vqtsw); 1378 + py_bind(mod, "vqtrw(bin: int) -> float", py_vqtrw); 1379 + py_bind(mod, "vqtrsw(bin: int) -> float", py_vqtrsw); 1316 1380 return true; 1317 1381 } 1318 1382
+44
src/api/scheme.c
··· 840 840 return s7_make_real(sc, core->api.vqtrs(tic, bin)); 841 841 } 842 842 843 + s7_pointer scheme_vqtw(s7_scheme* sc, s7_pointer args) 844 + { 845 + // vqtw(int bin) -> float_value 846 + tic_core* core = getSchemeCore(sc); 847 + tic_mem* tic = (tic_mem*)core; 848 + const int argn = s7_list_length(sc, args); 849 + const s32 bin = argn > 0 ? s7_integer(s7_car(args)) : 0; 850 + 851 + return s7_make_real(sc, core->api.vqtw(tic, bin)); 852 + } 853 + 854 + s7_pointer scheme_vqtsw(s7_scheme* sc, s7_pointer args) 855 + { 856 + // vqtsw(int bin) -> float_value 857 + tic_core* core = getSchemeCore(sc); 858 + tic_mem* tic = (tic_mem*)core; 859 + const int argn = s7_list_length(sc, args); 860 + const s32 bin = argn > 0 ? s7_integer(s7_car(args)) : 0; 861 + 862 + return s7_make_real(sc, core->api.vqtsw(tic, bin)); 863 + } 864 + 865 + s7_pointer scheme_vqtrw(s7_scheme* sc, s7_pointer args) 866 + { 867 + // vqtrw(int bin) -> float_value 868 + tic_core* core = getSchemeCore(sc); 869 + tic_mem* tic = (tic_mem*)core; 870 + const int argn = s7_list_length(sc, args); 871 + const s32 bin = argn > 0 ? s7_integer(s7_car(args)) : 0; 872 + 873 + return s7_make_real(sc, core->api.vqtrw(tic, bin)); 874 + } 875 + 876 + s7_pointer scheme_vqtrsw(s7_scheme* sc, s7_pointer args) 877 + { 878 + // vqtrsw(int bin) -> float_value 879 + tic_core* core = getSchemeCore(sc); 880 + tic_mem* tic = (tic_mem*)core; 881 + const int argn = s7_list_length(sc, args); 882 + const s32 bin = argn > 0 ? s7_integer(s7_car(args)) : 0; 883 + 884 + return s7_make_real(sc, core->api.vqtrsw(tic, bin)); 885 + } 886 + 843 887 static void initAPI(tic_core* core) 844 888 { 845 889 s7_scheme* sc = core->currentVM;
+80
src/api/squirrel.c
··· 1713 1713 return 0; 1714 1714 } 1715 1715 1716 + static SQInteger squirrel_vqtw(HSQUIRRELVM vm) 1717 + { 1718 + tic_core* core = getSquirrelCore(vm); 1719 + tic_mem* tic = (tic_mem*)core; 1720 + 1721 + SQInteger top = sq_gettop(vm); 1722 + 1723 + if (top >= 2) 1724 + { 1725 + double bin = getSquirrelNumber(vm, 2); 1726 + 1727 + sq_pushfloat(vm, (SQFloat)(core->api.vqtw(tic, bin))); 1728 + return 1; 1729 + } 1730 + 1731 + sq_throwerror(vm, "invalid params, vqtw(bin)\n"); 1732 + 1733 + return 0; 1734 + } 1735 + 1736 + static SQInteger squirrel_vqtsw(HSQUIRRELVM vm) 1737 + { 1738 + tic_core* core = getSquirrelCore(vm); 1739 + tic_mem* tic = (tic_mem*)core; 1740 + 1741 + SQInteger top = sq_gettop(vm); 1742 + 1743 + if (top >= 2) 1744 + { 1745 + double bin = getSquirrelNumber(vm, 2); 1746 + 1747 + sq_pushfloat(vm, (SQFloat)(core->api.vqtsw(tic, bin))); 1748 + return 1; 1749 + } 1750 + 1751 + sq_throwerror(vm, "invalid params, vqtsw(bin)\n"); 1752 + 1753 + return 0; 1754 + } 1755 + 1756 + static SQInteger squirrel_vqtrw(HSQUIRRELVM vm) 1757 + { 1758 + tic_core* core = getSquirrelCore(vm); 1759 + tic_mem* tic = (tic_mem*)core; 1760 + 1761 + SQInteger top = sq_gettop(vm); 1762 + 1763 + if (top >= 2) 1764 + { 1765 + double bin = getSquirrelNumber(vm, 2); 1766 + 1767 + sq_pushfloat(vm, (SQFloat)(core->api.vqtrw(tic, bin))); 1768 + return 1; 1769 + } 1770 + 1771 + sq_throwerror(vm, "invalid params, vqtrw(bin)\n"); 1772 + 1773 + return 0; 1774 + } 1775 + 1776 + static SQInteger squirrel_vqtrsw(HSQUIRRELVM vm) 1777 + { 1778 + tic_core* core = getSquirrelCore(vm); 1779 + tic_mem* tic = (tic_mem*)core; 1780 + 1781 + SQInteger top = sq_gettop(vm); 1782 + 1783 + if (top >= 2) 1784 + { 1785 + double bin = getSquirrelNumber(vm, 2); 1786 + 1787 + sq_pushfloat(vm, (SQFloat)(core->api.vqtrsw(tic, bin))); 1788 + return 1; 1789 + } 1790 + 1791 + sq_throwerror(vm, "invalid params, vqtrsw(bin)\n"); 1792 + 1793 + return 0; 1794 + } 1795 + 1716 1796 static SQInteger squirrel_dofile(HSQUIRRELVM vm) 1717 1797 { 1718 1798 return sq_throwerror(vm, "unknown method: \"dofile\"\n");
+76
src/api/wren.c
··· 148 148 foreign static exit()\n\ 149 149 foreign static fft(start_freq, end_freq)\n\ 150 150 foreign static ffts(start_freq, end_freq)\n\ 151 + foreign static vqtw(bin)\n\ 152 + foreign static vqtsw(bin)\n\ 153 + foreign static vqtrw(bin)\n\ 154 + foreign static vqtrsw(bin)\n\ 151 155 foreign static map_width__\n\ 152 156 foreign static map_height__\n\ 153 157 foreign static spritesize__\n\ ··· 1611 1615 wrenError(vm, "invalid params, vqtrs(bin)\n"); 1612 1616 } 1613 1617 1618 + static void wren_vqtw(WrenVM* vm) 1619 + { 1620 + tic_core* core = getWrenCore(vm); 1621 + tic_mem* tic = (tic_mem*)core; 1622 + s32 top = wrenGetSlotCount(vm); 1623 + 1624 + if (top > 1) 1625 + { 1626 + double bin = getWrenNumber(vm, 1); 1627 + 1628 + wrenSetSlotDouble(vm, 0, core->api.vqtw(tic, bin)); 1629 + return; 1630 + } 1631 + 1632 + wrenError(vm, "invalid params, vqtw(bin)\n"); 1633 + } 1634 + 1635 + static void wren_vqtsw(WrenVM* vm) 1636 + { 1637 + tic_core* core = getWrenCore(vm); 1638 + tic_mem* tic = (tic_mem*)core; 1639 + s32 top = wrenGetSlotCount(vm); 1640 + 1641 + if (top > 1) 1642 + { 1643 + double bin = getWrenNumber(vm, 1); 1644 + 1645 + wrenSetSlotDouble(vm, 0, core->api.vqtsw(tic, bin)); 1646 + return; 1647 + } 1648 + 1649 + wrenError(vm, "invalid params, vqtsw(bin)\n"); 1650 + } 1651 + 1652 + static void wren_vqtrw(WrenVM* vm) 1653 + { 1654 + tic_core* core = getWrenCore(vm); 1655 + tic_mem* tic = (tic_mem*)core; 1656 + s32 top = wrenGetSlotCount(vm); 1657 + 1658 + if (top > 1) 1659 + { 1660 + double bin = getWrenNumber(vm, 1); 1661 + 1662 + wrenSetSlotDouble(vm, 0, core->api.vqtrw(tic, bin)); 1663 + return; 1664 + } 1665 + 1666 + wrenError(vm, "invalid params, vqtrw(bin)\n"); 1667 + } 1668 + 1669 + static void wren_vqtrsw(WrenVM* vm) 1670 + { 1671 + tic_core* core = getWrenCore(vm); 1672 + tic_mem* tic = (tic_mem*)core; 1673 + s32 top = wrenGetSlotCount(vm); 1674 + 1675 + if (top > 1) 1676 + { 1677 + double bin = getWrenNumber(vm, 1); 1678 + 1679 + wrenSetSlotDouble(vm, 0, core->api.vqtrsw(tic, bin)); 1680 + return; 1681 + } 1682 + 1683 + wrenError(vm, "invalid params, vqtrsw(bin)\n"); 1684 + } 1685 + 1614 1686 static WrenForeignMethodFn foreignTicMethods(const char* signature) 1615 1687 { 1616 1688 if (strcmp(signature, "static TIC.btn()" ) == 0) return wren_btn; ··· 1726 1798 if (strcmp(signature, "static TIC.ffts(_,_)" ) == 0) return wren_ffts; 1727 1799 if (strcmp(signature, "static TIC.vqt(_)" ) == 0) return wren_vqt; 1728 1800 if (strcmp(signature, "static TIC.vqts(_)" ) == 0) return wren_vqts; 1801 + if (strcmp(signature, "static TIC.vqtw(_)" ) == 0) return wren_vqtw; 1802 + if (strcmp(signature, "static TIC.vqtsw(_)" ) == 0) return wren_vqtsw; 1729 1803 if (strcmp(signature, "static TIC.fftr(_,_)" ) == 0) return wren_fftr; 1730 1804 if (strcmp(signature, "static TIC.fftrs(_,_)" ) == 0) return wren_fftrs; 1731 1805 if (strcmp(signature, "static TIC.vqtr(_)" ) == 0) return wren_vqtr; 1732 1806 if (strcmp(signature, "static TIC.vqtrs(_)" ) == 0) return wren_vqtrs; 1807 + if (strcmp(signature, "static TIC.vqtrw(_)" ) == 0) return wren_vqtrw; 1808 + if (strcmp(signature, "static TIC.vqtrsw(_)" ) == 0) return wren_vqtrsw; 1733 1809 1734 1810 // internal functions 1735 1811 if (strcmp(signature, "static TIC.map_width__" ) == 0) return wren_map_width;
+2 -2
src/vqtdata.h
··· 21 21 #endif 22 22 23 23 #ifndef VQT_WHITENING_WIDTH_BINS 24 - #define VQT_WHITENING_WIDTH_BINS 11 // odd window width for envelope smoothing 24 + #define VQT_WHITENING_WIDTH_BINS 21 // odd window width for envelope smoothing 25 25 #endif 26 26 27 27 #ifndef VQT_WHITENING_STRENGTH 28 - #define VQT_WHITENING_STRENGTH 0.7f // 0..1 mix toward whitened spectrum 28 + #define VQT_WHITENING_STRENGTH 0.95f // 0..1 mix toward whitened spectrum 29 29 #endif 30 30 31 31 #ifndef VQT_WHITENING_EPS