Removing all 3dnow/MMX stuff - it was broken anyway. Additionally all
authorterminatorX <>
Fri, 28 Mar 2003 19:32:44 +0000 (19:32 +0000)
committerterminatorX <>
Fri, 28 Mar 2003 19:32:44 +0000 (19:32 +0000)
occurences of USE_FLASH have been eliminated - Alex

12 files changed:
AUTHORS
src/3dnow.h [deleted file]
src/Makefile.am
src/README.MMX [deleted file]
src/main.cc
src/mmx.h [deleted file]
src/tX_dialog.cc
src/tX_mastergui.cc
src/tX_vtt.cc
src/tX_vtt.h
src/tX_vttgui.cc
src/tX_vttgui.h

diff --git a/AUTHORS b/AUTHORS
index fd240b19b009af8eb1e9e28fe905c9632db58a1f..e4ba9e4015d4e9122c281e6af5fa971eebba6d17 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -11,10 +11,5 @@ misc fixes and enhancements:
                        Adrian Reber <adrian@lisas.de>
 Ogg Vorbis support:    Matthew Evans <activesx@hotmail.com>
                        
-Authors of files not written for tX but included in this distribution:
-mmx.h README.MMX:      Hank Dietz <hankd@ecn.purdue.ed> and
-                       Randy Fisher <rfisher@ecn.purdue.edu>
-3dnow.h:               Robert Dale <rob@nb.net>
-
-The lowpass filter is based on:
+The lowpass filter is based on a description:
 reso_lop.txt:          Paul Kellett <paul.kellett@maxim.abel.co.uk>
diff --git a/src/3dnow.h b/src/3dnow.h
deleted file mode 100644 (file)
index 58db1ab..0000000
+++ /dev/null
@@ -1,95 +0,0 @@
-/*  3DNow! interface library
- *  Copyright (C) 1998 Robert Dale
- *  
- *  This depends on mmx.h which should have been included.
- *
- */ 
-
-#include "mmx.h"
-
-/* 3DNow! instructions */
-
-#define femms() \
-        __asm__ __volatile__ ("femms")
-
-#define pf2id_m2r(var, reg)    mmx_m2r(pf2id, var, reg)
-#define pf2id_r2r(regs, regd)  mmx_r2r(pf2id, regs, regd)
-#define pf2id(vars, vard)      mmx_m2m(pf2id, vars, vard)
-
-#define pfacc_m2r(var, reg)    mmx_m2r(pfacc, var, reg)
-#define pfacc_r2r(regs, regd)  mmx_r2r(pfacc, regs, regd)
-#define pfacc(vars, vard)      mmx_m2m(pfacc, vars, vard)
-
-#define pfadd_i2r(imm, reg)    mmx_i2r(pfadd, imm, reg)
-#define pfadd_m2r(var, reg)    mmx_m2r(pfadd, var, reg)
-#define pfadd_r2r(regs, regd)  mmx_r2r(pfadd, regs, regd)
-#define pfadd(vars, vard)      mmx_m2m(pfadd, vars, vard)
-
-#define pfcmpeq_m2r(var, reg)  mmx_m2r(pfcmpeq, var, reg)
-#define pfcmpeq_r2r(regs, regd) mmx_r2r(pfcmpeq, regs, regd)
-#define pfcmpeq(vars, vard)     mmx_m2m(pfcmpeq, vars, vard)
-
-#define pfcmpge_m2r(var, reg)   mmx_m2r(pfcmpge, var, reg)
-#define pfcmpge_r2r(regs, regd) mmx_r2r(pfcmpge, regs, regd)
-#define pfcmpge(vars, vard)     mmx_m2m(pfcmpge, vars, vard)
-
-#define pfcmpgt_m2r(var, reg)   mmx_m2r(pfcmpgt, var, reg)
-#define pfcmpgt_r2r(regs, regd) mmx_r2r(pfcmpgt, regs, regd)
-#define pfcmpgt(vars, vard)     mmx_m2m(pfcmpgt, vars, vard)
-
-#define pfmax_m2r(var, reg)     mmx_m2r(pfmax, var, reg)
-#define pfmax_r2r(regs, regd)   mmx_r2r(pfmax, regs, regd)
-#define pfmax(vars, vard)       mmx_m2m(pfmax, vars, vard)
-
-#define pfmin_m2r(var, reg)     mmx_m2r(pfmin, var, reg)
-#define pfmin_r2r(regs, regd)   mmx_r2r(pfmin, regs, regd)
-#define pfmin(vars, vard)       mmx_m2m(pfmin, vars, vard)
-
-#define pfmul_i2r(imm, reg)     mmx_i2r(pfmul, imm, reg)
-#define pfmul_m2r(var, reg)     mmx_m2r(pfmul, var, reg)
-#define pfmul_r2r(regs, regd)   mmx_r2r(pfmul, regs, regd)
-#define pfmul(vars, vard)       mmx_m2m(pfmul, vars, vard)
-
-#define pfrcp_m2r(var, reg)     mmx_m2r(pfrcp, var, reg)
-#define pfrcp_r2r(regs, regd)   mmx_r2r(pfrcp, regs, regd)
-#define pfrcp(vars, vard)       mmx_m2m(pfrcp, vars, vard)
-
-#define pfrcpit1_m2r(var, reg)  mmx_m2r(pfrcpit1, var, reg)
-#define pfrcpit1_r2r(regs, regd) mmx_r2r(pfrcpit1, regs, regd)
-#define pfrcpit1(vars, vard)    mmx_m2m(pfrcpit1, vars, vard)
-
-#define pfrcpit2_m2r(var, reg)  mmx_m2r(pfrcpit2, var, reg)
-#define pfrcpit2_r2r(regs, regd) mmx_r2r(pfrcpit2, regs, regd)
-#define pfrcpit2(vars, vard)    mmx_m2m(pfrcpit2, vars, vard)
-
-#define pfrsqrt_m2r(var, reg)   mmx_m2r(pfrsqrt, var, reg)
-#define pfrsqrt_r2r(regs, regd) mmx_r2r(pfrsqrt, regs, regd)
-#define pfrsqrt(vars, vard)     mmx_m2m(pfrsqrt, vars, vard)
-
-#define pfrsqit1_m2r(var, reg)   mmx_m2r(pfrsqit1, var, reg)
-#define pfrsqit1_r2r(regs, regd) mmx_r2r(pfrsqit1, regs, regd)
-#define pfrsqit1(vars, vard)     mmx_m2m(pfrsqit1, vars, vard)
-
-#define pfsub_m2r(var, reg)     mmx_m2r(pfsub, var, reg)
-#define pfsub_r2r(regs, regd)   mmx_r2r(pfsub, regs, regd)
-#define pfsub(vars, vard)       mmx_m2m(pfsub, vars, vard)
-
-#define pfsubr_m2r(var, reg)    mmx_m2r(pfsubr, var, reg)
-#define pfsubr_r2r(regs, regd)  mmx_r2r(pfsubr, regs, regd)
-#define pfsubr(vars, vard)      mmx_m2m(pfsubr, vars, vard)
-
-#define pi2fd_m2r(var, reg)     mmx_m2r(pi2fd, var, reg)
-#define pi2fd_r2r(regs, regd)   mmx_r2r(pi2fd, regs, regd)
-#define pi2fd(vars, vard)       mmx_m2m(pi2fd, vars, vard)
-
-#define pavgusb_m2r(var, reg)   mmx_m2r(pavgusb, var, reg)
-#define pavgusb_r2r(regs, regd) mmx_r2r(pavgusb, regs, regd)
-#define pavgusb(vars, vard)     mmx_m2m(pavgusb, vars, vard)
-
-#define pmulhrw_m2r(var, reg)   mmx_m2r(pmulhrw, var, reg)
-#define pmulhrw_r2r(regs, regd) mmx_r2r(pmulhrw, regs, regd)
-#define pmulhrw(vars, vard)     mmx_m2m(pmulhrw, vars, vard)
-
-#define prefetch()           __asm__ __volatile__ ("prefetch") 
-
-#define prefetchw()          __asm__ __volatile__ ("prefetchw") 
index c0fb6742cc0c696ea8ddd0c7c6cf2486e9e5fb49..edf97cd3627440c1466c1ab57b57971c9ee31a69 100644 (file)
@@ -2,8 +2,6 @@ LIBS=@X_LIBS@ @GTK_LIBS@ @LIBS@
 
 SUBDIRS = gui_icons smallknob
 
-EXTRA_DIST = README.MMX
-
 CFLAGS=@CFLAGS@ @GTK_CFLAGS@ -D_REENTRANT
 CXXFLAGS=@CFLAGS@ @GTK_CFLAGS@ -D_REENTRANT
 
@@ -26,7 +24,7 @@ terminatorX_SOURCES = tX_endian.c tX_dialog.cc tX_widget.c wav_write.c \
                        tX_dialog.h tX_mastergui.h tX_widget.h wav_file.h \
                        tX_vtt.cc tX_vtt.h tX_vttgui.h tX_vttgui.cc \
                        tX_audiodevice.cc tX_audiodevice.h tX_mastergui.cc \
-                       3dnow.h mmx.h tX_audiofile.cc \
+                       tX_audiofile.cc \
                        tX_audiofile.h tX_loaddlg.cc tX_loaddlg.h tX_icon.c \
                        tX_icon.h tX_prelis.cc tX_prelis.h \
                        tX_seqpar.h tX_seqpar.cc tX_pbutton.cc tX_pbutton.h \
diff --git a/src/README.MMX b/src/README.MMX
deleted file mode 100644 (file)
index eb7c4ab..0000000
+++ /dev/null
@@ -1,195 +0,0 @@
-*** NOTE: This is the README for libmmx by Hank Dietz and Randy Fisher.
-Although libmmx seems to be completely Public Domain I didn't want to use the
-code without the info. BTW If you want to use mmx.h for some other project
-PLEASE get the original distribution as I had to modify the included mmx.h
-slightly.
-
-Now follow "README" and "acknowledgments" from libmmx.
-*** NOTE END
-README for libmmx.
-
-General Information:
-       The home site for libmmx is off the SWAR homepage at Purdue University:
-               http://shay.ecn.purdue.edu/~swar
-
-       libmmx was written by Hank Dietz and Randy Fisher, who can currently be
-       contacted at:
-               hankd@ecn.purdue.edu
-               rfisher@ecn.purdue.edu
-
-       Please include "libmmx" in the subject line of any correspondence
-       pertaining to the library.
-
-       Please see the file "bug-reports" for information on reporting
-       problems with the library.
-
-       Please read the file INSTALL for information on making and istalling
-       the library, or the file UPGRADE for information on upgrading from an
-       earlier version of libmmx.
-
-Introduction:
-
-       Intel's MMX family of multimedia extensions to the x86 instruction
-       set contains CPU instructions which allow a single operation to be
-       applied to multiple data items simultaneously.  This data is stored
-       in a "partitioned" floating-point (FP) register, meaning that the
-       register is logically divided into multiple independent sections
-       called "fields", each of which can hold a single datum.  For
-       example, a 64-bit register may be partitioned into two 32-bit
-       fields, with the first consisting of bits 0 through 31 and the
-       second consisting of bits 32-63.
-
-       Throughout this document, and all SWAR literature, the notation AxB
-       will be used to indicate a register partitioning of A fields of B
-       bits each.  "AxB" is read as "A by B".  For example, a 64-bit
-       register can be partitioned as 4 fields of 16-bits each (4 by 16).
-       The notation "AxBu" indicates A fields of B bits each, containing
-       unsigned integer data, and the notation "AxBf" indicates A fields of
-       B bits each, containing floating point data.
-
-       Once the data has been stored in the partitioned register, MMX
-       instructions can be used to operate simultaneously on all the fields
-       of the register.  Most of these instructions are "non-interfering",
-       meaning that their application to one field is independent of their
-       application to any other field of the same register.  In this manner,
-       a single operation can be applied to multiple data streams
-       concurrently.  Thus, the MMX instructions treat the fields of a
-       partitioned register as though they were equivalent registers on
-       separate nodes of a SIMD parallel computer.  We refer to this type of
-       processing as SWAR (SIMD Within A Register).
-
-       This library is intended to provide C function level support for the
-       MMX instruction set.  It does so by providing a data type for
-       partitioned registers, and functions which allow operands of this
-       type to be passed to an MMX instruction and returned from it, loaded
-       in MMX registers, and stored from MMX registers to memory.  All of
-       the original MMX instructions are supported by the library.
-
-       The libmmx functions access MMX instructions via inline assembly and
-       use the MMX support provided by the GNU assembler (gas) versions
-       2.8.1 and later.  It is possible to modify the library sources to use
-       earlier versions of gas, however, we suggest that you upgrade to a
-       newer version of gas if possible.
-
-
-The mmx_t data type union:
-       
-       The data is either signed or unsigned, integer, and may be 8, 16, 32,
-       or 64 bits long.  libmmx stores the contents of each register as an
-       unsigned 64-bit entity which may take one of several forms.  This
-       first-class type union is defined to be "mmx_t" in the header file
-       "mmx.h":
-
-       typedef union {
-               long long               q;      /* Quadword */
-               unsigned long long      uq;     /* Unsigned Quadword */
-               int                     d[2];   /* 2 Doublewords */
-               unsigned int            ud[2];  /* 2 Unsigned Doublewords */
-               short                   w[4];   /* 4 Words */
-               unsigned short          uw[4];  /* 4 Unsigned Words */
-               char                    b[8];   /* 8 Bytes */
-               unsigned char           ub[8];  /* 8 Unsigned Bytes */
-       } mmx_t;
-
-       Within an application, variables of type mmx_t are declared as
-       normal, and can be initialized by initializing the "elements" of the
-       chosen partitioning as would be done for an array:
-                       mmx_t a,
-                       mmx_t b.d = {456L, 98L};
-                       mmx_t c.q = 0xF1F2F3F4F5F6F7F8LL;
-
-       Values may be set within the application by setting the elements of
-       the chosen partitioning:
-                       a.q = 0xF1F2F3F4F5F6F7F8LL;
-                       b.d[1] = 456L; b.d[0] = 98L;
-                       c.uw[3] = 3; c.uw[2] = 2; c.uw[1] = 1; c.uw[0] = 0;
-
-       Because the data is stored as a single mmx_t, there is no inherent
-       partitioning due to the storage type.  The partitioning of the
-       register is dependent only upon the operation applied, and is not
-       enforced by the library between operations.  Thus, data may be
-       stored in an mmx_t variable with an 2x32 partitioning, then a 4x16
-       addition can be applied to the mmx_t variable, immediately followed
-       by an 8x8 addition.  It is left to the programmer to use the proper
-       version of each instruction to maintain the desired partitioning
-       throughout an application.
-
-       Note that the data may be accessed with various partitionings.  Thus,
-       the following sequence is legal:
-                       a.q = 0x0123456789abcdefLL;
-                       a.d[1] = a.d[0];
-                       a.w[3] = a.d[2];
-                       a.w[1] = a.d[0];
-                       a.ub[7] = a.b[6];
-                       a.ub[5] = a.b[4];
-                       a.ub[3] = a.b[2];
-                       a.ub[1] = a.b[0];
-
-       Immediate data can be used where a value of type mmx_t is required by
-       casting it to be a value of one of the types within the mmx_t union,
-       then casting it to be an mmx_t value:
-                       mmx_t a;
-                       a = (mmx_t) (long long) 0x0123456789abcdefLL;
-       Notice we did not say "a.q" here.
-
-
-Using libmmx in an application:
-
-       To use libmmx in an application, the header file "mmx.h" must be
-       #included in the application before any variables of type mmx are
-       declared, and before the first occurrence of a libmmx function.
-
-       The processor's floating point registers must usable in MMX mode
-       for any MMX instruction to be used, and must be put back into FP mode
-       once MMX operations have concluded.  mmx_ok() checks to see if the
-       processor supports MMX.  If so, mmx_ok() returns 1, otherwise, it
-       returns 0.  This return value may be checked by a program, and allows
-       MMX code to be skipped or alternative code to be used if MMX is not
-       supported by the CPU.  mm_support() can be used to see which multimedia
-       extensions are supported by the processor including MMX, Extended MMX,
-       and 3DNow!, although the library currently only supports standard MMX.
-
-       If MMX is supported, any of the other libmmx functions may be called.
-
-       When these are completed, emms() must be called to place the CPU back
-       into FP mode, and must be called before any FP instructions are used
-       which follow an MMX instruction.
-
-       See the document "functions" for complete descriptions of the libmmx
-       functions.
-
-
-Using MMX_TRACE:
-       Defining MMX_TRACE before the inclusion of mmx.h, either in the
-       source or on the compiler command line, enables the printing of
-       trace information onto stderr.  This information should be useful
-       for debugging and optimizing your code.
-
-Acknowledgments:
-Jussi Laako for pointing out the errors ultimately found to be connected to the
-failure to notify the optimizer of clobbered values.
-
-Roger Hardiman for reminding us that CPUID isn't everywhere, and that someone
-may actually try to use this on a machine without CPUID.  Also for suggesting
-code for checking this.
-
-Robert Dale for pointing out the AMD recognition bug.
-
-Jimmy Mayfield and Carl Witty for pointing out the Intel recognition bug.
-
-Serge Krier for pointing out missing i2r versions of shifts (on same weekend I
-realized it was missing, but thanks for the note).
-
-Carl Witty for pointing out the psllq_i2r test bug.
-
-Franco Bez for pointing out and testing the Cyrix recognition problem.
-
-Valient Gough for alignment suggestion and indicating, and suggesting a fix
-for, the _i2r tracing bug.
-
-Franco Bez for help with the egcs i2r bugs.
-
-Hugh Holbrook for catching the latest %% bug, for suggesting the use of
-"gcc -E" as a replacement for cpp which may not be easy to find, and for
-noting the ecgs warnings about __volatile__ with __asm__.
-
index bb3f71fba5e8c6b445eb5c78619194abeb77450b..85d8bddbec750971316f40f844e614ec6d2ee84d 100644 (file)
 #include <config.h>
 #endif
 
-#ifdef USE_3DNOW
-#include "3dnow.h"
-#endif
-
 #include "tX_endian.h"
 #include "tX_types.h"
 #include "tX_global.h"
 GTimer *my_time;
 gint idle_tag;
 
-#ifdef USE_3DNOW
-/*     Function to test if multimedia instructions are supported...
-*/
-inline int
-tx_mm_support(void)
-{
-       /* Returns 1 if MMX instructions are supported,
-          3 if Cyrix MMX and Extended MMX instructions are supported
-          5 if AMD MMX and 3DNow! instructions are supported
-          0 if hardware does not support any of these
-       */
-       register int rval = 0;
-
-       __asm__ __volatile__ (
-               /* See if CPUID instruction is supported ... */
-               /* ... Get copies of EFLAGS into eax and ecx */
-               "pushf\n\t"
-               "popl %%eax\n\t"
-               "movl %%eax, %%ecx\n\t"
-
-               /* ... Toggle the ID bit in one copy and store */
-               /*     to the EFLAGS reg */
-               "xorl $0x200000, %%eax\n\t"
-               "push %%eax\n\t"
-               "popf\n\t"
-
-               /* ... Get the (hopefully modified) EFLAGS */
-               "pushf\n\t"
-               "popl %%eax\n\t"
-
-               /* ... Compare and test result */
-               "xorl %%eax, %%ecx\n\t"
-               "testl $0x200000, %%ecx\n\t"
-               "jz NotSupported1\n\t"          /* CPUID not supported */
-
-
-               /* Get standard CPUID information, and
-                      go to a specific vendor section */
-               "movl $0, %%eax\n\t"
-               "cpuid\n\t"
-
-               /* Check for Intel */
-               "cmpl $0x756e6547, %%ebx\n\t"
-               "jne TryAMD\n\t"
-               "cmpl $0x49656e69, %%edx\n\t"
-               "jne TryAMD\n\t"
-               "cmpl $0x6c65746e, %%ecx\n"
-               "jne TryAMD\n\t"
-               "jmp Intel\n\t"
-
-               /* Check for AMD */
-               "\nTryAMD:\n\t"
-               "cmpl $0x68747541, %%ebx\n\t"
-               "jne TryCyrix\n\t"
-               "cmpl $0x69746e65, %%edx\n\t"
-               "jne TryCyrix\n\t"
-               "cmpl $0x444d4163, %%ecx\n"
-               "jne TryCyrix\n\t"
-               "jmp AMD\n\t"
-
-               /* Check for Cyrix */
-               "\nTryCyrix:\n\t"
-               "cmpl $0x69727943, %%ebx\n\t"
-               "jne NotSupported2\n\t"
-               "cmpl $0x736e4978, %%edx\n\t"
-               "jne NotSupported3\n\t"
-               "cmpl $0x64616574, %%ecx\n\t"
-               "jne NotSupported4\n\t"
-               /* Drop through to Cyrix... */
-
-
-               /* Cyrix Section */
-               /* See if extended CPUID level 80000001 is supported */
-               /* The value of CPUID/80000001 for the 6x86MX is undefined
-                  according to the Cyrix CPU Detection Guide (Preliminary
-                  Rev. 1.01 table 1), so we'll check the value of eax for
-                  CPUID/0 to see if standard CPUID level 2 is supported.
-                  According to the table, the only CPU which supports level
-                  2 is also the only one which supports extended CPUID levels.
-               */
-               "cmpl $0x2, %%eax\n\t"
-               "jne MMXtest\n\t"       /* Use standard CPUID instead */
-
-               /* Extended CPUID supported (in theory), so get extended
-                  features */
-               "movl $0x80000001, %%eax\n\t"
-               "cpuid\n\t"
-               "testl $0x00800000, %%eax\n\t"  /* Test for MMX */
-               "jz NotSupported5\n\t"          /* MMX not supported */
-               "testl $0x01000000, %%eax\n\t"  /* Test for Ext'd MMX */
-               "jnz EMMXSupported\n\t"
-               "movl $1, %0\n\n\t"             /* MMX Supported */
-               "jmp Return\n\n"
-               "EMMXSupported:\n\t"
-               "movl $3, %0\n\n\t"             /* EMMX and MMX Supported */
-               "jmp Return\n\t"
-
-
-               /* AMD Section */
-               "AMD:\n\t"
-
-               /* See if extended CPUID is supported */
-               "movl $0x80000000, %%eax\n\t"
-               "cpuid\n\t"
-               "cmpl $0x80000000, %%eax\n\t"
-               "jl MMXtest\n\t"        /* Use standard CPUID instead */
-
-               /* Extended CPUID supported, so get extended features */
-               "movl $0x80000001, %%eax\n\t"
-               "cpuid\n\t"
-               "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
-               "jz NotSupported6\n\t"          /* MMX not supported */
-               "testl $0x80000000, %%edx\n\t"  /* Test for 3DNow! */
-               "jnz ThreeDNowSupported\n\t"
-               "movl $1, %0\n\n\t"             /* MMX Supported */
-               "jmp Return\n\n"
-               "ThreeDNowSupported:\n\t"
-               "movl $5, %0\n\n\t"             /* 3DNow! and MMX Supported */
-               "jmp Return\n\t"
-
-
-               /* Intel Section */
-               "Intel:\n\t"
-
-               /* Check for MMX */
-               "MMXtest:\n\t"
-               "movl $1, %%eax\n\t"
-               "cpuid\n\t"
-               "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
-               "jz NotSupported7\n\t"          /* MMX Not supported */
-               "movl $1, %0\n\n\t"             /* MMX Supported */
-               "jmp Return\n\t"
-
-               /* Nothing supported */
-               "\nNotSupported1:\n\t"
-               "#movl $101, %0\n\n\t"
-               "\nNotSupported2:\n\t"
-               "#movl $102, %0\n\n\t"
-               "\nNotSupported3:\n\t"
-               "#movl $103, %0\n\n\t"
-               "\nNotSupported4:\n\t"
-               "#movl $104, %0\n\n\t"
-               "\nNotSupported5:\n\t"
-               "#movl $105, %0\n\n\t"
-               "\nNotSupported6:\n\t"
-               "#movl $106, %0\n\n\t"
-               "\nNotSupported7:\n\t"
-               "#movl $107, %0\n\n\t"
-               "movl $0, %0\n\n\t"
-
-               "Return:\n\t"
-               : "=g" (rval)
-               : /* no input */
-               : "eax", "ebx", "ecx", "edx"
-       );
-
-       /* Return */
-       return(rval);
-}
-
-#endif
-
 int idle()
 {
        gdouble time;
@@ -340,19 +174,6 @@ int parse_args(int *argc, char **argv)
                                 exit(1);
                        }
                }
-/*             
-               else if ((strcmp(argv[i], "-m") == 0) || (strcmp(argv[i], "--midi-in") == 0))
-               {
-               }
-               else if ((strcmp(argv[i], "-s") == 0) || (strcmp(argv[i], "--std-out") == 0))
-               {
-               }       
-               else if ((strcmp(argv[i], "-n") == 0) || (strcmp(argv[i], "--no-gui") == 0))
-               {
-                       globals.no_gui = 1;
-                       fprintf(stderr, "tX: Run without a GUI\n");
-               }
-*/
                else
                {
                        show_help();
@@ -369,15 +190,9 @@ int main(int argc, char **argv)
 
        tX_engine *engine=tX_engine::get_instance();
        
-#ifdef USE_3DNOW
-       if (tx_mm_support()!=5) {
-               printf("3DNow! not detected. Giving up.\n");
-               return(1);
-       } else printf("3DNow! accelerations available.\n");     
-#endif
+       gtk_init (&argc, &argv);
+       gtk_set_locale();
        
-    gtk_init (&argc, &argv);
-       gtk_set_locale ();
        parse_args(&argc, argv); 
 
        if (globals.show_nag) { 
@@ -391,8 +206,6 @@ int main(int argc, char **argv)
        
        LADSPA_Class :: init();
        LADSPA_Plugin :: init();
-//     LADSPA_Plugin :: status();
-//     LADSPA_Class :: dump();
        
        create_mastergui(globals.width, globals.height);
                
diff --git a/src/mmx.h b/src/mmx.h
deleted file mode 100644 (file)
index ddf25c7..0000000
--- a/src/mmx.h
+++ /dev/null
@@ -1,706 +0,0 @@
-/*     mmx.h
-
-       MultiMedia eXtensions GCC interface library for IA32.
-
-       To use this library, simply include this header file
-       and compile with GCC.  You MUST have inlining enabled
-       in order for mmx_ok() to work; this can be done by
-       simply using -O on the GCC command line.
-
-       Compiling with -DMMX_TRACE will cause detailed trace
-       output to be sent to stderr for each mmx operation.
-       This adds lots of code, and obviously slows execution to
-       a crawl, but can be very useful for debugging.
-
-       THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
-       EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
-       LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
-       AND FITNESS FOR ANY PARTICULAR PURPOSE.
-
-       1997-99 by H. Dietz and R. Fisher
-
- Notes:
-       It appears that the latest gas has the pand problem fixed, therefore
-         I'll undefine BROKEN_PAND by default.
-*/
-
-#ifndef _MMX_H
-#define _MMX_H
-
-
-/*     Warning:  at this writing, the version of GAS packaged
-       with most Linux distributions does not handle the
-       parallel AND operation mnemonic correctly.  If the
-       symbol BROKEN_PAND is defined, a slower alternative
-       coding will be used.  If execution of mmxtest results
-       in an illegal instruction fault, define this symbol.
-*/
-#undef BROKEN_PAND
-
-
-/*     The type of an value that fits in an MMX register
-       (note that long long constant values MUST be suffixed
-        by LL and unsigned long long values by ULL, lest
-        they be truncated by the compiler)
-*/
-typedef        union {
-       long long               q;      /* Quadword (64-bit) value */
-       unsigned long long      uq;     /* Unsigned Quadword */
-       int                     d[2];   /* 2 Doubleword (32-bit) values */
-       unsigned int            ud[2];  /* 2 Unsigned Doubleword */
-       short                   w[4];   /* 4 Word (16-bit) values */
-       unsigned short          uw[4];  /* 4 Unsigned Word */
-       char                    b[8];   /* 8 Byte (8-bit) values */
-       unsigned char           ub[8];  /* 8 Unsigned Byte */
-       float                   s[2];   /* Single-precision (32-bit) value */
-} __attribute__ ((aligned (8))) mmx_t; /* On an 8-byte (64-bit) boundary */
-
-
-
-/*     Function to test if multimedia instructions are supported...
-*/
-inline int
-mm_support(void)
-{
-       /* Returns 1 if MMX instructions are supported,
-          3 if Cyrix MMX and Extended MMX instructions are supported
-          5 if AMD MMX and 3DNow! instructions are supported
-          0 if hardware does not support any of these
-       */
-       register int rval = 0;
-
-       __asm__ __volatile__ (
-               /* See if CPUID instruction is supported ... */
-               /* ... Get copies of EFLAGS into eax and ecx */
-               "pushf\n\t"
-               "popl %%eax\n\t"
-               "movl %%eax, %%ecx\n\t"
-
-               /* ... Toggle the ID bit in one copy and store */
-               /*     to the EFLAGS reg */
-               "xorl $0x200000, %%eax\n\t"
-               "push %%eax\n\t"
-               "popf\n\t"
-
-               /* ... Get the (hopefully modified) EFLAGS */
-               "pushf\n\t"
-               "popl %%eax\n\t"
-
-               /* ... Compare and test result */
-               "xorl %%eax, %%ecx\n\t"
-               "testl $0x200000, %%ecx\n\t"
-               "jz NotSupported1\n\t"          /* CPUID not supported */
-
-
-               /* Get standard CPUID information, and
-                      go to a specific vendor section */
-               "movl $0, %%eax\n\t"
-               "cpuid\n\t"
-
-               /* Check for Intel */
-               "cmpl $0x756e6547, %%ebx\n\t"
-               "jne TryAMD\n\t"
-               "cmpl $0x49656e69, %%edx\n\t"
-               "jne TryAMD\n\t"
-               "cmpl $0x6c65746e, %%ecx\n"
-               "jne TryAMD\n\t"
-               "jmp Intel\n\t"
-
-               /* Check for AMD */
-               "\nTryAMD:\n\t"
-               "cmpl $0x68747541, %%ebx\n\t"
-               "jne TryCyrix\n\t"
-               "cmpl $0x69746e65, %%edx\n\t"
-               "jne TryCyrix\n\t"
-               "cmpl $0x444d4163, %%ecx\n"
-               "jne TryCyrix\n\t"
-               "jmp AMD\n\t"
-
-               /* Check for Cyrix */
-               "\nTryCyrix:\n\t"
-               "cmpl $0x69727943, %%ebx\n\t"
-               "jne NotSupported2\n\t"
-               "cmpl $0x736e4978, %%edx\n\t"
-               "jne NotSupported3\n\t"
-               "cmpl $0x64616574, %%ecx\n\t"
-               "jne NotSupported4\n\t"
-               /* Drop through to Cyrix... */
-
-
-               /* Cyrix Section */
-               /* See if extended CPUID level 80000001 is supported */
-               /* The value of CPUID/80000001 for the 6x86MX is undefined
-                  according to the Cyrix CPU Detection Guide (Preliminary
-                  Rev. 1.01 table 1), so we'll check the value of eax for
-                  CPUID/0 to see if standard CPUID level 2 is supported.
-                  According to the table, the only CPU which supports level
-                  2 is also the only one which supports extended CPUID levels.
-               */
-               "cmpl $0x2, %%eax\n\t"
-               "jne MMXtest\n\t"       /* Use standard CPUID instead */
-
-               /* Extended CPUID supported (in theory), so get extended
-                  features */
-               "movl $0x80000001, %%eax\n\t"
-               "cpuid\n\t"
-               "testl $0x00800000, %%eax\n\t"  /* Test for MMX */
-               "jz NotSupported5\n\t"          /* MMX not supported */
-               "testl $0x01000000, %%eax\n\t"  /* Test for Ext'd MMX */
-               "jnz EMMXSupported\n\t"
-               "movl $1, %0\n\n\t"             /* MMX Supported */
-               "jmp Return\n\n"
-               "EMMXSupported:\n\t"
-               "movl $3, %0\n\n\t"             /* EMMX and MMX Supported */
-               "jmp Return\n\t"
-
-
-               /* AMD Section */
-               "AMD:\n\t"
-
-               /* See if extended CPUID is supported */
-               "movl $0x80000000, %%eax\n\t"
-               "cpuid\n\t"
-               "cmpl $0x80000000, %%eax\n\t"
-               "jl MMXtest\n\t"        /* Use standard CPUID instead */
-
-               /* Extended CPUID supported, so get extended features */
-               "movl $0x80000001, %%eax\n\t"
-               "cpuid\n\t"
-               "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
-               "jz NotSupported6\n\t"          /* MMX not supported */
-               "testl $0x80000000, %%edx\n\t"  /* Test for 3DNow! */
-               "jnz ThreeDNowSupported\n\t"
-               "movl $1, %0\n\n\t"             /* MMX Supported */
-               "jmp Return\n\n"
-               "ThreeDNowSupported:\n\t"
-               "movl $5, %0\n\n\t"             /* 3DNow! and MMX Supported */
-               "jmp Return\n\t"
-
-
-               /* Intel Section */
-               "Intel:\n\t"
-
-               /* Check for MMX */
-               "MMXtest:\n\t"
-               "movl $1, %%eax\n\t"
-               "cpuid\n\t"
-               "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
-               "jz NotSupported7\n\t"          /* MMX Not supported */
-               "movl $1, %0\n\n\t"             /* MMX Supported */
-               "jmp Return\n\t"
-
-               /* Nothing supported */
-               "\nNotSupported1:\n\t"
-               "#movl $101, %0\n\n\t"
-               "\nNotSupported2:\n\t"
-               "#movl $102, %0\n\n\t"
-               "\nNotSupported3:\n\t"
-               "#movl $103, %0\n\n\t"
-               "\nNotSupported4:\n\t"
-               "#movl $104, %0\n\n\t"
-               "\nNotSupported5:\n\t"
-               "#movl $105, %0\n\n\t"
-               "\nNotSupported6:\n\t"
-               "#movl $106, %0\n\n\t"
-               "\nNotSupported7:\n\t"
-               "#movl $107, %0\n\n\t"
-               "movl $0, %0\n\n\t"
-
-               "Return:\n\t"
-               : "=g" (rval)
-               : /* no input */
-               : "eax", "ebx", "ecx", "edx"
-       );
-
-       /* Return */
-       return(rval);
-}
-
-/*     Function to test if mmx instructions are supported...
-*/
-inline extern int
-mmx_ok(void)
-{
-       /* Returns 1 if MMX instructions are supported, 0 otherwise */
-       return ( mm_support() & 0x1 );
-}
-
-
-/*     Helper functions for the instruction macros that follow...
-       (note that memory-to-register, m2r, instructions are nearly
-        as efficient as register-to-register, r2r, instructions;
-        however, memory-to-memory instructions are really simulated
-        as a convenience, and are only 1/3 as efficient)
-*/
-#ifdef MMX_TRACE
-
-/*     Include the stuff for printing a trace to stderr...
-*/
-
-#include <stdio.h>
-
-#define        mmx_i2r(op, imm, reg) \
-       { \
-               mmx_t mmx_trace; \
-               mmx_trace.uq = (imm); \
-               fprintf(stderr, #op "_i2r(" #imm "=0x%08x%08x, ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ ("movq %%" #reg ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #reg "=0x%08x%08x) => ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ (#op " %0, %%" #reg \
-                                     : /* nothing */ \
-                                     : "X" (imm)); \
-               __asm__ __volatile__ ("movq %%" #reg ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #reg "=0x%08x%08x\n", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-       }
-
-#define        mmx_m2r(op, mem, reg) \
-       { \
-               mmx_t mmx_trace; \
-               mmx_trace = (mem); \
-               fprintf(stderr, #op "_m2r(" #mem "=0x%08x%08x, ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ ("movq %%" #reg ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #reg "=0x%08x%08x) => ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ (#op " %0, %%" #reg \
-                                     : /* nothing */ \
-                                     : "X" (mem)); \
-               __asm__ __volatile__ ("movq %%" #reg ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #reg "=0x%08x%08x\n", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-       }
-
-#define        mmx_r2m(op, reg, mem) \
-       { \
-               mmx_t mmx_trace; \
-               __asm__ __volatile__ ("movq %%" #reg ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #op "_r2m(" #reg "=0x%08x%08x, ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               mmx_trace = (mem); \
-               fprintf(stderr, #mem "=0x%08x%08x) => ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ (#op " %%" #reg ", %0" \
-                                     : "=X" (mem) \
-                                     : /* nothing */ ); \
-               mmx_trace = (mem); \
-               fprintf(stderr, #mem "=0x%08x%08x\n", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-       }
-
-#define        mmx_r2r(op, regs, regd) \
-       { \
-               mmx_t mmx_trace; \
-               __asm__ __volatile__ ("movq %%" #regs ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #op "_r2r(" #regs "=0x%08x%08x, ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ ("movq %%" #regd ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #regd "=0x%08x%08x) => ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ (#op " %" #regs ", %" #regd); \
-               __asm__ __volatile__ ("movq %%" #regd ", %0" \
-                                     : "=X" (mmx_trace) \
-                                     : /* nothing */ ); \
-               fprintf(stderr, #regd "=0x%08x%08x\n", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-       }
-
-#define        mmx_m2m(op, mems, memd) \
-       { \
-               mmx_t mmx_trace; \
-               mmx_trace = (mems); \
-               fprintf(stderr, #op "_m2m(" #mems "=0x%08x%08x, ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               mmx_trace = (memd); \
-               fprintf(stderr, #memd "=0x%08x%08x) => ", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-               __asm__ __volatile__ ("movq %0, %%mm0\n\t" \
-                                     #op " %1, %%mm0\n\t" \
-                                     "movq %%mm0, %0" \
-                                     : "=X" (memd) \
-                                     : "X" (mems)); \
-               mmx_trace = (memd); \
-               fprintf(stderr, #memd "=0x%08x%08x\n", \
-                       mmx_trace.d[1], mmx_trace.d[0]); \
-       }
-
-#else
-
-/*     These macros are a lot simpler without the tracing...
-*/
-
-#define        mmx_i2r(op, imm, reg) \
-       __asm__ __volatile__ (#op " %0, %%" #reg \
-                             : /* nothing */ \
-                             : "X" (imm) )
-
-#define        mmx_m2r(op, mem, reg) \
-       __asm__ __volatile__ (#op " %0, %%" #reg \
-                             : /* nothing */ \
-                             : "X" (mem))
-
-#define        mmx_r2m(op, reg, mem) \
-       __asm__ __volatile__ (#op " %%" #reg ", %0" \
-                             : "=X" (mem) \
-                             : /* nothing */ )
-
-#define        mmx_r2r(op, regs, regd) \
-       __asm__ __volatile__ (#op " %" #regs ", %" #regd)
-
-#define        mmx_m2m(op, mems, memd) \
-       __asm__ __volatile__ ("movq %0, %%mm0\n\t" \
-                             #op " %1, %%mm0\n\t" \
-                             "movq %%mm0, %0" \
-                             : "=X" (memd) \
-                             : "X" (mems))
-
-#endif
-
-
-/*     1x64 MOVe Quadword
-       (this is both a load and a store...
-        in fact, it is the only way to store)
-*/
-#define        movq_m2r(var, reg)      mmx_m2r(movq, var, reg)
-#define        movq_r2m(reg, var)      mmx_r2m(movq, reg, var)
-#define        movq_r2r(regs, regd)    mmx_r2r(movq, regs, regd)
-#define        movq(vars, vard) \
-       __asm__ __volatile__ ("movq %1, %%mm0\n\t" \
-                             "movq %%mm0, %0" \
-                             : "=X" (vard) \
-                             : "X" (vars))
-
-
-/*     1x32 MOVe Doubleword
-       (like movq, this is both load and store...
-        but is most useful for moving things between
-        mmx registers and ordinary registers)
-*/
-#define        movd_m2r(var, reg)      mmx_m2r(movd, var, reg)
-#define        movd_r2m(reg, var)      mmx_r2m(movd, reg, var)
-#define        movd_r2r(regs, regd)    mmx_r2r(movd, regs, regd)
-#define        movd(vars, vard) \
-       __asm__ __volatile__ ("movd %1, %%mm0\n\t" \
-                             "movd %%mm0, %0" \
-                             : "=X" (vard) \
-                             : "X" (vars))
-
-
-/*     2x32, 4x16, and 8x8 Parallel ADDs
-*/
-#define        paddd_m2r(var, reg)     mmx_m2r(paddd, var, reg)
-#define        paddd_r2r(regs, regd)   mmx_r2r(paddd, regs, regd)
-#define        paddd(vars, vard)       mmx_m2m(paddd, vars, vard)
-
-#define        paddw_m2r(var, reg)     mmx_m2r(paddw, var, reg)
-#define        paddw_r2r(regs, regd)   mmx_r2r(paddw, regs, regd)
-#define        paddw(vars, vard)       mmx_m2m(paddw, vars, vard)
-
-#define        paddb_m2r(var, reg)     mmx_m2r(paddb, var, reg)
-#define        paddb_r2r(regs, regd)   mmx_r2r(paddb, regs, regd)
-#define        paddb(vars, vard)       mmx_m2m(paddb, vars, vard)
-
-
-/*     4x16 and 8x8 Parallel ADDs using Saturation arithmetic
-*/
-#define        paddsw_m2r(var, reg)    mmx_m2r(paddsw, var, reg)
-#define        paddsw_r2r(regs, regd)  mmx_r2r(paddsw, regs, regd)
-#define        paddsw(vars, vard)      mmx_m2m(paddsw, vars, vard)
-
-#define        paddsb_m2r(var, reg)    mmx_m2r(paddsb, var, reg)
-#define        paddsb_r2r(regs, regd)  mmx_r2r(paddsb, regs, regd)
-#define        paddsb(vars, vard)      mmx_m2m(paddsb, vars, vard)
-
-
-/*     4x16 and 8x8 Parallel ADDs using Unsigned Saturation arithmetic
-*/
-#define        paddusw_m2r(var, reg)   mmx_m2r(paddusw, var, reg)
-#define        paddusw_r2r(regs, regd) mmx_r2r(paddusw, regs, regd)
-#define        paddusw(vars, vard)     mmx_m2m(paddusw, vars, vard)
-
-#define        paddusb_m2r(var, reg)   mmx_m2r(paddusb, var, reg)
-#define        paddusb_r2r(regs, regd) mmx_r2r(paddusb, regs, regd)
-#define        paddusb(vars, vard)     mmx_m2m(paddusb, vars, vard)
-
-
-/*     2x32, 4x16, and 8x8 Parallel SUBs
-*/
-#define        psubd_m2r(var, reg)     mmx_m2r(psubd, var, reg)
-#define        psubd_r2r(regs, regd)   mmx_r2r(psubd, regs, regd)
-#define        psubd(vars, vard)       mmx_m2m(psubd, vars, vard)
-
-#define        psubw_m2r(var, reg)     mmx_m2r(psubw, var, reg)
-#define        psubw_r2r(regs, regd)   mmx_r2r(psubw, regs, regd)
-#define        psubw(vars, vard)       mmx_m2m(psubw, vars, vard)
-
-#define        psubb_m2r(var, reg)     mmx_m2r(psubb, var, reg)
-#define        psubb_r2r(regs, regd)   mmx_r2r(psubb, regs, regd)
-#define        psubb(vars, vard)       mmx_m2m(psubb, vars, vard)
-
-
-/*     4x16 and 8x8 Parallel SUBs using Saturation arithmetic
-*/
-#define        psubsw_m2r(var, reg)    mmx_m2r(psubsw, var, reg)
-#define        psubsw_r2r(regs, regd)  mmx_r2r(psubsw, regs, regd)
-#define        psubsw(vars, vard)      mmx_m2m(psubsw, vars, vard)
-
-#define        psubsb_m2r(var, reg)    mmx_m2r(psubsb, var, reg)
-#define        psubsb_r2r(regs, regd)  mmx_r2r(psubsb, regs, regd)
-#define        psubsb(vars, vard)      mmx_m2m(psubsb, vars, vard)
-
-
-/*     4x16 and 8x8 Parallel SUBs using Unsigned Saturation arithmetic
-*/
-#define        psubusw_m2r(var, reg)   mmx_m2r(psubusw, var, reg)
-#define        psubusw_r2r(regs, regd) mmx_r2r(psubusw, regs, regd)
-#define        psubusw(vars, vard)     mmx_m2m(psubusw, vars, vard)
-
-#define        psubusb_m2r(var, reg)   mmx_m2r(psubusb, var, reg)
-#define        psubusb_r2r(regs, regd) mmx_r2r(psubusb, regs, regd)
-#define        psubusb(vars, vard)     mmx_m2m(psubusb, vars, vard)
-
-
-/*     4x16 Parallel MULs giving Low 4x16 portions of results
-*/
-#define        pmullw_m2r(var, reg)    mmx_m2r(pmullw, var, reg)
-#define        pmullw_r2r(regs, regd)  mmx_r2r(pmullw, regs, regd)
-#define        pmullw(vars, vard)      mmx_m2m(pmullw, vars, vard)
-
-
-/*     4x16 Parallel MULs giving High 4x16 portions of results
-*/
-#define        pmulhw_m2r(var, reg)    mmx_m2r(pmulhw, var, reg)
-#define        pmulhw_r2r(regs, regd)  mmx_r2r(pmulhw, regs, regd)
-#define        pmulhw(vars, vard)      mmx_m2m(pmulhw, vars, vard)
-
-
-/*     4x16->2x32 Parallel Mul-ADD
-       (muls like pmullw, then adds adjacent 16-bit fields
-        in the multiply result to make the final 2x32 result)
-*/
-#define        pmaddwd_m2r(var, reg)   mmx_m2r(pmaddwd, var, reg)
-#define        pmaddwd_r2r(regs, regd) mmx_r2r(pmaddwd, regs, regd)
-#define        pmaddwd(vars, vard)     mmx_m2m(pmaddwd, vars, vard)
-
-
-/*     1x64 bitwise AND
-*/
-#ifdef BROKEN_PAND
-#define        pand_m2r(var, reg) \
-       { \
-               mmx_m2r(pandn, (mmx_t) -1LL, reg); \
-               mmx_m2r(pandn, var, reg); \
-       }
-#define        pand_r2r(regs, regd) \
-       { \
-               mmx_m2r(pandn, (mmx_t) -1LL, regd); \
-               mmx_r2r(pandn, regs, regd) \
-       }
-#define        pand(vars, vard) \
-       { \
-               movq_m2r(vard, mm0); \
-               mmx_m2r(pandn, (mmx_t) -1LL, mm0); \
-               mmx_m2r(pandn, vars, mm0); \
-               movq_r2m(mm0, vard); \
-       }
-#else
-#define        pand_m2r(var, reg)      mmx_m2r(pand, var, reg)
-#define        pand_r2r(regs, regd)    mmx_r2r(pand, regs, regd)
-#define        pand(vars, vard)        mmx_m2m(pand, vars, vard)
-#endif
-
-
-/*     1x64 bitwise AND with Not the destination
-*/
-#define        pandn_m2r(var, reg)     mmx_m2r(pandn, var, reg)
-#define        pandn_r2r(regs, regd)   mmx_r2r(pandn, regs, regd)
-#define        pandn(vars, vard)       mmx_m2m(pandn, vars, vard)
-
-
-/*     1x64 bitwise OR
-*/
-#define        por_m2r(var, reg)       mmx_m2r(por, var, reg)
-#define        por_r2r(regs, regd)     mmx_r2r(por, regs, regd)
-#define        por(vars, vard) mmx_m2m(por, vars, vard)
-
-
-/*     1x64 bitwise eXclusive OR
-*/
-#define        pxor_m2r(var, reg)      mmx_m2r(pxor, var, reg)
-#define        pxor_r2r(regs, regd)    mmx_r2r(pxor, regs, regd)
-#define        pxor(vars, vard)        mmx_m2m(pxor, vars, vard)
-
-
-/*     2x32, 4x16, and 8x8 Parallel CoMPare for EQuality
-       (resulting fields are either 0 or -1)
-*/
-#define        pcmpeqd_m2r(var, reg)   mmx_m2r(pcmpeqd, var, reg)
-#define        pcmpeqd_r2r(regs, regd) mmx_r2r(pcmpeqd, regs, regd)
-#define        pcmpeqd(vars, vard)     mmx_m2m(pcmpeqd, vars, vard)
-
-#define        pcmpeqw_m2r(var, reg)   mmx_m2r(pcmpeqw, var, reg)
-#define        pcmpeqw_r2r(regs, regd) mmx_r2r(pcmpeqw, regs, regd)
-#define        pcmpeqw(vars, vard)     mmx_m2m(pcmpeqw, vars, vard)
-
-#define        pcmpeqb_m2r(var, reg)   mmx_m2r(pcmpeqb, var, reg)
-#define        pcmpeqb_r2r(regs, regd) mmx_r2r(pcmpeqb, regs, regd)
-#define        pcmpeqb(vars, vard)     mmx_m2m(pcmpeqb, vars, vard)
-
-
-/*     2x32, 4x16, and 8x8 Parallel CoMPare for Greater Than
-       (resulting fields are either 0 or -1)
-*/
-#define        pcmpgtd_m2r(var, reg)   mmx_m2r(pcmpgtd, var, reg)
-#define        pcmpgtd_r2r(regs, regd) mmx_r2r(pcmpgtd, regs, regd)
-#define        pcmpgtd(vars, vard)     mmx_m2m(pcmpgtd, vars, vard)
-
-#define        pcmpgtw_m2r(var, reg)   mmx_m2r(pcmpgtw, var, reg)
-#define        pcmpgtw_r2r(regs, regd) mmx_r2r(pcmpgtw, regs, regd)
-#define        pcmpgtw(vars, vard)     mmx_m2m(pcmpgtw, vars, vard)
-
-#define        pcmpgtb_m2r(var, reg)   mmx_m2r(pcmpgtb, var, reg)
-#define        pcmpgtb_r2r(regs, regd) mmx_r2r(pcmpgtb, regs, regd)
-#define        pcmpgtb(vars, vard)     mmx_m2m(pcmpgtb, vars, vard)
-
-
-/*     1x64, 2x32, and 4x16 Parallel Shift Left Logical
-*/
-#define        psllq_i2r(imm, reg)     mmx_i2r(psllq, imm, reg)
-#define        psllq_m2r(var, reg)     mmx_m2r(psllq, var, reg)
-#define        psllq_r2r(regs, regd)   mmx_r2r(psllq, regs, regd)
-#define        psllq(vars, vard)       mmx_m2m(psllq, vars, vard)
-
-#define        pslld_i2r(imm, reg)     mmx_i2r(pslld, imm, reg)
-#define        pslld_m2r(var, reg)     mmx_m2r(pslld, var, reg)
-#define        pslld_r2r(regs, regd)   mmx_r2r(pslld, regs, regd)
-#define        pslld(vars, vard)       mmx_m2m(pslld, vars, vard)
-
-#define        psllw_i2r(imm, reg)     mmx_i2r(psllw, imm, reg)
-#define        psllw_m2r(var, reg)     mmx_m2r(psllw, var, reg)
-#define        psllw_r2r(regs, regd)   mmx_r2r(psllw, regs, regd)
-#define        psllw(vars, vard)       mmx_m2m(psllw, vars, vard)
-
-
-/*     1x64, 2x32, and 4x16 Parallel Shift Right Logical
-*/
-#define        psrlq_i2r(imm, reg)     mmx_i2r(psrlq, imm, reg)
-#define        psrlq_m2r(var, reg)     mmx_m2r(psrlq, var, reg)
-#define        psrlq_r2r(regs, regd)   mmx_r2r(psrlq, regs, regd)
-#define        psrlq(vars, vard)       mmx_m2m(psrlq, vars, vard)
-
-#define        psrld_i2r(imm, reg)     mmx_i2r(psrld, imm, reg)
-#define        psrld_m2r(var, reg)     mmx_m2r(psrld, var, reg)
-#define        psrld_r2r(regs, regd)   mmx_r2r(psrld, regs, regd)
-#define        psrld(vars, vard)       mmx_m2m(psrld, vars, vard)
-
-#define        psrlw_i2r(imm, reg)     mmx_i2r(psrlw, imm, reg)
-#define        psrlw_m2r(var, reg)     mmx_m2r(psrlw, var, reg)
-#define        psrlw_r2r(regs, regd)   mmx_r2r(psrlw, regs, regd)
-#define        psrlw(vars, vard)       mmx_m2m(psrlw, vars, vard)
-
-
-/*     2x32 and 4x16 Parallel Shift Right Arithmetic
-*/
-#define        psrad_i2r(imm, reg)     mmx_i2r(psrad, imm, reg)
-#define        psrad_m2r(var, reg)     mmx_m2r(psrad, var, reg)
-#define        psrad_r2r(regs, regd)   mmx_r2r(psrad, regs, regd)
-#define        psrad(vars, vard)       mmx_m2m(psrad, vars, vard)
-
-#define        psraw_i2r(imm, reg)     mmx_i2r(psraw, imm, reg)
-#define        psraw_m2r(var, reg)     mmx_m2r(psraw, var, reg)
-#define        psraw_r2r(regs, regd)   mmx_r2r(psraw, regs, regd)
-#define        psraw(vars, vard)       mmx_m2m(psraw, vars, vard)
-
-
-/*     2x32->4x16 and 4x16->8x8 PACK and Signed Saturate
-       (packs source and dest fields into dest in that order)
-*/
-#define        packssdw_m2r(var, reg)  mmx_m2r(packssdw, var, reg)
-#define        packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
-#define        packssdw(vars, vard)    mmx_m2m(packssdw, vars, vard)
-
-#define        packsswb_m2r(var, reg)  mmx_m2r(packsswb, var, reg)
-#define        packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
-#define        packsswb(vars, vard)    mmx_m2m(packsswb, vars, vard)
-
-
-/*     4x16->8x8 PACK and Unsigned Saturate
-       (packs source and dest fields into dest in that order)
-*/
-#define        packuswb_m2r(var, reg)  mmx_m2r(packuswb, var, reg)
-#define        packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
-#define        packuswb(vars, vard)    mmx_m2m(packuswb, vars, vard)
-
-
-/*     2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK Low
-       (interleaves low half of dest with low half of source
-        as padding in each result field)
-*/
-#define        punpckldq_m2r(var, reg) mmx_m2r(punpckldq, var, reg)
-#define        punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
-#define        punpckldq(vars, vard)   mmx_m2m(punpckldq, vars, vard)
-
-#define        punpcklwd_m2r(var, reg) mmx_m2r(punpcklwd, var, reg)
-#define        punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
-#define        punpcklwd(vars, vard)   mmx_m2m(punpcklwd, vars, vard)
-
-#define        punpcklbw_m2r(var, reg) mmx_m2r(punpcklbw, var, reg)
-#define        punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
-#define        punpcklbw(vars, vard)   mmx_m2m(punpcklbw, vars, vard)
-
-
-/*     2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK High
-       (interleaves high half of dest with high half of source
-        as padding in each result field)
-*/
-#define        punpckhdq_m2r(var, reg) mmx_m2r(punpckhdq, var, reg)
-#define        punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
-#define        punpckhdq(vars, vard)   mmx_m2m(punpckhdq, vars, vard)
-
-#define        punpckhwd_m2r(var, reg) mmx_m2r(punpckhwd, var, reg)
-#define        punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
-#define        punpckhwd(vars, vard)   mmx_m2m(punpckhwd, vars, vard)
-
-#define        punpckhbw_m2r(var, reg) mmx_m2r(punpckhbw, var, reg)
-#define        punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
-#define        punpckhbw(vars, vard)   mmx_m2m(punpckhbw, vars, vard)
-
-
-/*     Empty MMx State
-       (used to clean-up when going from mmx to float use
-        of the registers that are shared by both; note that
-        there is no float-to-mmx operation needed, because
-        only the float tag word info is corruptible)
-*/
-#ifdef MMX_TRACE
-
-#define        emms() \
-       { \
-               fprintf(stderr, "emms()\n"); \
-               __asm__ __volatile__ ("emms"); \
-       }
-
-#else
-
-#define        emms()                  __asm__ __volatile__ ("emms")
-
-#endif
-
-#endif
-
index 4c9aef8331a3bb9005a2baed729558574fb2e8f3..4db58d4d34b9682dca784cdf1a2112cc9e550995 100644 (file)
@@ -499,13 +499,6 @@ void show_about(int nag)
                "OFF"
 #endif
 
-               " - 3DNow!: "
-#ifdef USE_3DNOW
-               "ON"
-#else
-               "OFF"
-#endif
-               
                " - enhanced scheduling: "
 #ifdef USE_SCHEDULER
                "ON"
index 7902397b966623806f5521c5fecdc5009a81289f..0ea0e26d89f7aec038d54e0ef26526fd608a9c17 100644 (file)
@@ -1207,7 +1207,6 @@ void create_mastergui(int x, int y)
        gtk_widget_show(dummy); 
        gui_set_tooltip(dummy, "Adjust the master volume. This parameter will effect *all* turntables in the set.");
        
-#ifdef USE_FLASH       
        main_flash_r=gtk_tx_flash_new();
        gtk_box_pack_end(GTK_BOX(master_vol_box), main_flash_r, WID_DYN);
        gtk_widget_show(main_flash_r);
@@ -1215,7 +1214,7 @@ void create_mastergui(int x, int y)
        main_flash_l=gtk_tx_flash_new();
        gtk_box_pack_end(GTK_BOX(master_vol_box), main_flash_l, WID_DYN);
        gtk_widget_show(main_flash_l);
-#endif 
+
        dummy=gtk_label_new("Volume");
        gtk_misc_set_alignment(GTK_MISC(dummy), 0.5, 0.5);
        gtk_box_pack_start(GTK_BOX(right_hbox), dummy, WID_FIX);
index ab824346666f4fe012b6b2176d20eedcba722efe..33042f6d5da9ac784a424ae8b00ada8525973b4f 100644 (file)
 #include <config.h>
 #endif
 
-#ifdef USE_3DNOW
-#include "3dnow.h"
-#endif
-
 #ifdef DEBUG
 #define tX_freemem(ptr, varname, comment); fprintf(stderr, "** free() [%s] at %08x. %s.\n", varname, ptr, comment); free(ptr);
 #define tX_malloc(ptr, varname, comment, size, type); fprintf(stderr, "**[1/2] malloc() [%s]. Size: %i. %s.\n", varname, size, comment); ptr=type malloc(size); fprintf(stderr, "**[2/2] malloc() [%s]. ptr: %08x.\n", varname, ptr);
@@ -323,10 +319,6 @@ void vtt_class :: recalc_volume()
                ec_volume_left=ec_volume_right=ec_res_volume;
        }       
 //     printf("vtt_volume: %f, %f, l: %f, r: %f\n", rel_volume, res_volume, res_volume_left, res_volume_right);
-       
-#ifdef USE_3DNOW
-       mm_res_volume.s[0]=mm_res_volume.s[1]=res_volume;
-#endif 
 }
 
 void vtt_class :: set_pan(f_prec newpan)
@@ -882,60 +874,8 @@ int16_t * vtt_class :: render_all_turntables()
        int sample;
        int mix_sample;
        f_prec temp;
-
-#ifdef USE_3DNOW
-       mmx_t *mix;
-       mmx_t *vtt_buffer;
-       int32_t *mix_int;
-#endif
-
-#ifdef USE_FLASH
        f_prec max;
        f_prec min;
-#ifdef USE_3DNOW
-       mmx_t mm_max;
-       mmx_t mm_min;
-       mmx_t mm_volume;
-       mmx_t mm_src1;
-       mmx_t mm_src2;
-
-#ifndef OVERRIDE_MOVQ_AUTODETECT
-#ifndef GCC_VERSION
-#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
-#endif /* GCC_VERSION */
-
-#if (GCC_VERSION < 2096)
-#warning "*************************"
-#warning "* gcc < 2.96            *"
-#warning "* assuming working movq *"
-#warning "*************************"
-#undef GCC_MOVQ_BUG_WORKAROUND
-#else
-#warning "*************************"
-#warning "* gcc >= 2.96           *"
-#warning "* using movq-workaround *"
-#warning "*************************"
-#define GCC_MOVQ_BUG_WORKAROUND 1
-#endif /* GCC < 2.96 */
-#endif /* OVERRIDE MOVQ AUTODETECVT */
-       
-#ifdef GCC_MOVQ_BUG_WORKAROUND
-       /* REQUIRED DUE TO GCC BUG (2.96-3.0.2) */
-       mmx_t *mm_src1_ptr=&mm_src1;
-       mmx_t *mm_src2_ptr=&mm_src2;
-       mmx_t *mm_volume_ptr=&mm_volume;
-       mmx_t *mm_max_ptr=&mm_max;
-       mmx_t *mm_min_ptr=&mm_min;
-       
-#define MM_VAR_ACC(var) (* var ## _ptr)
-#define MM_VAR_MOVQ(var) * var ## _ptr
-#else
-#define MM_VAR_ACC(var) var
-#define MM_VAR_MOVQ(var) var
-#endif 
-       int32_t *temp_int=&mm_max.d[1];
-#endif 
-#endif 
        
        pthread_mutex_lock(&render_lock);
        
@@ -953,7 +893,6 @@ int16_t * vtt_class :: render_all_turntables()
                        max=(*vtt)->max_value;
                        min=max;
 
-#ifndef USE_3DNOW
                        for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
                        {                               
                                temp=(*vtt)->output_buffer[sample];
@@ -965,65 +904,12 @@ int16_t * vtt_class :: render_all_turntables()
                                if (temp>max) max=temp;
                                else if (temp<min) min=temp;
                        }
-#else
-                       MM_VAR_ACC(mm_volume).s[0]=(*vtt)->res_volume_left;
-                       MM_VAR_ACC(mm_volume).s[1]=(*vtt)->res_volume_right;
-
-                       MM_VAR_ACC(mm_max).s[1]=MM_VAR_ACC(mm_max).s[0]=max;
-                       MM_VAR_ACC(mm_min).s[1]=MM_VAR_ACC(mm_min).s[0]=min;
-                       
-                       movq_m2r(MM_VAR_MOVQ(mm_max), mm1);
-                       movq_m2r(MM_VAR_MOVQ(mm_min), mm2);
-                                                       
-                       movq_m2r(MM_VAR_MOVQ(mm_volume), mm0);
-                       
-                       mix=(mmx_t*)mix_buffer;
-                       
-                       for (f_prec* src=(*vtt)->output_buffer; mix < (mmx_t*) mix_buffer_end;)
-                       {
-                               /* first sample */
-                               MM_VAR_ACC(mm_src1).s[0]=*src;
-                               MM_VAR_ACC(mm_src1).s[1]=*src;
-                                       
-                               /* sample * l/r volume */
-                               movq_m2r(MM_VAR_MOVQ(mm_src1), mm3);
-                               pfmul_r2r(mm0, mm3);
-                               movq_r2m(mm3, *mix);
-                                       
-                               /* next sample */
-                               src++, mix++;
-                               MM_VAR_ACC(mm_src2).s[0]=*src;
-                               MM_VAR_ACC(mm_src2).s[1]=*src;
-                                       
-                               /* sample * l/r volume */
-                               movq_m2r(MM_VAR_MOVQ(mm_src2), mm3);
-                               pfmul_r2r(mm0, mm3);
-                               movq_r2m(mm3, *mix);
-                                       
-                               /* calculating min/max */
-                               MM_VAR_ACC(mm_src1).s[1]=MM_VAR_ACC(mm_src2).s[0];
-                               movq_m2r(mm_src1, mm3);
-                               pfmax_r2r(mm3, mm1);
-                               pfmin_r2r(mm3, mm2);
-                               
-                               src++, mix++;
-                       }
-
-                       movq_r2m(mm1, MM_VAR_MOVQ(mm_max));
-                       movq_r2m(mm2, MM_VAR_MOVQ(mm_min));
-                       
-                       femms();
-                       
-                       if (MM_VAR_ACC(mm_max).s[0]>MM_VAR_ACC(mm_max).s[1]) max=MM_VAR_ACC(mm_max).s[0]; else max=MM_VAR_ACC(mm_max).s[1];
-                       if (MM_VAR_ACC(mm_min).s[0]<MM_VAR_ACC(mm_min).s[0]) min=MM_VAR_ACC(mm_min).s[0]; else min=MM_VAR_ACC(mm_min).s[1];
-#endif                 
                        
                        min*=-1.0;
                        if (min>max) (*vtt)->max_value=min; else (*vtt)->max_value=max;
 
                        if ((*vtt)->ec_enable)
                        {
-#ifndef USE_3DNOW                      
                                for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
                                {                               
                                        temp=(*vtt)->ec_output_buffer[sample];
@@ -1033,30 +919,6 @@ int16_t * vtt_class :: render_all_turntables()
                                        mix_buffer[mix_sample]+=temp*(*vtt)->ec_volume_right;
                                        mix_sample++;
                                }
-#else
-                               MM_VAR_ACC(mm_volume).s[0]=(*vtt)->ec_volume_left;
-                               MM_VAR_ACC(mm_volume).s[1]=(*vtt)->ec_volume_right;
-                                               
-                               movq_m2r(MM_VAR_MOVQ(mm_volume), mm0);
-                               mix =(mmx_t*)mix_buffer;
-
-                               for (f_prec* src=(*vtt)->ec_output_buffer; mix < (mmx_t*) mix_buffer_end; src++, mix++)
-                               {
-                                       /* first sample */
-                                       MM_VAR_ACC(mm_src1).s[0]=*src;
-                                       MM_VAR_ACC(mm_src1).s[1]=*src;
-                               
-                                       /* sample * l/r volume */
-                                       movq_m2r(MM_VAR_MOVQ(mm_src1), mm3);
-                                       pfmul_r2r(mm0, mm3);
-                               
-                                       /* accumulating complete mix */
-                                       movq_m2r(*mix, mm4);
-                                       pfadd_r2r(mm4, mm3);
-                                       movq_r2m(mm3, *mix);
-                               }
-                               femms();
-#endif                         
                        }
                        
                        if (master_triggered)
@@ -1087,7 +949,6 @@ int16_t * vtt_class :: render_all_turntables()
                                max=(*vtt)->max_value;
                                min=max;
 
-#ifndef USE_3DNOW
                                for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
                                {                               
                                        temp=(*vtt)->output_buffer[sample];
@@ -1099,72 +960,12 @@ int16_t * vtt_class :: render_all_turntables()
                                        if (temp>max) max=temp;
                                        else if (temp<min) min=temp;
                                }
-#else
-                               MM_VAR_ACC(mm_volume).s[0]=(*vtt)->res_volume_left;
-                               MM_VAR_ACC(mm_volume).s[1]=(*vtt)->res_volume_right;
-
-                               MM_VAR_ACC(mm_max).s[1]=MM_VAR_ACC(mm_max).s[0]=max;
-                               MM_VAR_ACC(mm_min).s[1]=MM_VAR_ACC(mm_min).s[0]=min;
-                       
-                               movq_m2r(MM_VAR_MOVQ(mm_max), mm1);
-                               movq_m2r(MM_VAR_MOVQ(mm_min), mm2);
-                                                       
-                               movq_m2r(MM_VAR_MOVQ(mm_volume), mm0);
-                               mix=(mmx_t*)mix_buffer;
-
-                               for (f_prec* src=(*vtt)->output_buffer; mix < (mmx_t*) mix_buffer_end;)
-                               {
-                                       /* first sample */
-                                       MM_VAR_ACC(mm_src1).s[0]=*src;
-                                       MM_VAR_ACC(mm_src1).s[1]=*src;
-                                       
-                                       /* sample * l/r volume */
-                                       movq_m2r(MM_VAR_MOVQ(mm_src1), mm3);
-                                       pfmul_r2r(mm0, mm3);
-                                       
-                                       /* accumulating complete mix */
-                                       movq_m2r(*mix, mm4);
-                                       pfadd_r2r(mm4, mm3);
-                                       movq_r2m(mm3, *mix);
-                                       
-                                       /* next sample */
-                                       src++, mix++;
-                                       MM_VAR_ACC(mm_src2).s[0]=*src;
-                                       MM_VAR_ACC(mm_src2).s[1]=*src;
-                                       
-                                       /* sample * l/r volume */
-                                       movq_m2r(MM_VAR_MOVQ(mm_src2), mm3);
-                                       pfmul_r2r(mm0, mm3);
-
-                                       /* accumulating complete mix */
-                                       movq_m2r(*mix, mm4);
-                                       pfadd_r2r(mm4, mm3);
-                                       movq_r2m(mm3, *mix);
-                                       
-                                       /* calculating min/max */
-                                       MM_VAR_ACC(mm_src1).s[1]=MM_VAR_ACC(mm_src2).s[0];
-                                       movq_m2r(MM_VAR_MOVQ(mm_src1), mm3);
-                                       pfmax_r2r(mm3, mm1);
-                                       pfmin_r2r(mm3, mm2);
-                                       
-                                       src++, mix++;
-                               }
-
-                               movq_r2m(mm1, MM_VAR_MOVQ(mm_max));
-                               movq_r2m(mm2, MM_VAR_MOVQ(mm_min));
-                               
-                               femms();
-       
-                               if (MM_VAR_ACC(mm_max).s[0]>MM_VAR_ACC(mm_max).s[1]) max=MM_VAR_ACC(mm_max).s[0]; else max=MM_VAR_ACC(mm_max).s[1];
-                               if (MM_VAR_ACC(mm_min).s[0]<MM_VAR_ACC(mm_min).s[0]) min=MM_VAR_ACC(mm_min).s[0]; else min=MM_VAR_ACC(mm_min).s[1];
-#endif
                                
                                min*=-1.0;
                                if (min>max) (*vtt)->max_value=min; else (*vtt)->max_value=max;
                                
                                if ((*vtt)->ec_enable)
                                {
-#ifndef USE_3DNOW
                                        for (sample=0, mix_sample=0; sample<(*vtt)->samples_in_outputbuffer; sample++)
                                        {                               
                                                temp=(*vtt)->ec_output_buffer[sample];
@@ -1174,31 +975,6 @@ int16_t * vtt_class :: render_all_turntables()
                                                mix_buffer[mix_sample]+=temp*(*vtt)->ec_volume_right;
                                                mix_sample++;
                                        }
-#else
-                                       MM_VAR_ACC(mm_volume).s[0]=(*vtt)->ec_volume_left;
-                                       MM_VAR_ACC(mm_volume).s[1]=(*vtt)->ec_volume_right;
-                                               
-                                       movq_m2r(MM_VAR_MOVQ(mm_volume), mm0);
-                                       mix =(mmx_t*)mix_buffer;
-
-                                       for (f_prec* src=(*vtt)->ec_output_buffer; mix < (mmx_t*) mix_buffer_end; src++, mix++)
-                                       {
-                                               /* first sample */
-                                               MM_VAR_ACC(mm_src1).s[0]=*src;
-                                               MM_VAR_ACC(mm_src1).s[1]=*src;
-                               
-                                               /* sample * l/r volume */
-                                               movq_m2r(MM_VAR_MOVQ(mm_src1), mm3);
-                                               pfmul_r2r(mm0, mm3);
-                               
-                                               /* accumulating complete mix */
-                                               movq_m2r(*mix, mm4);
-                                               pfadd_r2r(mm4, mm3);
-                                               movq_r2m(mm3, *mix);
-                                       }
-
-                                       femms();
-#endif                                 
                                }
                        }
                        
@@ -1337,10 +1113,7 @@ int vtt_class :: trigger()
                (*effect)->activate();
        }
 
-
-#ifdef USE_FLASH
        max_value=0;
-#endif
        
        if (is_sync_master)
        {
@@ -1378,10 +1151,8 @@ int vtt_class :: stop_nolock()
        want_stop=0;
 
        is_playing=0;
-
-#ifdef USE_FLASH
        max_value=0;
-#endif
+
        cleanup_vtt(this);
        sync_countdown=0;
        
index 89be7f55fb6357f3a4605d14c291fe43b3970b79..271375b5918a7586402c9beb7146b02f491e9cd0 100644 (file)
 
 #include <config.h>
 
-#ifdef DONT_USE_FLASH
-#undef USE_FLASH
-#else
-#define USE_FLASH 1
-#endif
-
 #include <list>
 #include "tX_types.h"
 #include "tX_vttgui.h"
 #include "tX_vttfx.h"
 #include "tX_ladspa.h"
 
-#ifdef USE_3DNOW
-#include "3dnow.h"
-#endif
-
 #define EC_MAX_BUFFER 256000
 
 #define NEED_FADE_OUT 0
@@ -115,9 +105,7 @@ class vtt_class
        vtt_fx* lp_fx;
        vtt_fx* ec_fx;
 
-#ifdef USE_FLASH
        f_prec max_value;
-#endif
        
        int16_t *buffer;        // Actual audio data
        unsigned int samples_in_buffer;  // No. of samples in audio data
@@ -131,9 +119,6 @@ class vtt_class
        /* main playback vars */
        f_prec rel_volume; // The (user-selected) relative volume
        f_prec res_volume; // The resulting volume
-#ifdef USE_3DNOW
-       mmx_t mm_res_volume;
-#endif 
        f_prec rel_pitch; // The (user-selected) relative pitch
        f_prec res_pitch;
        
index 8180720dea9ab9e0b86a85671e662d9212b81ea0..ba9e8d686fcb71e088179718a7cfff24a41d6e15 100644 (file)
@@ -54,9 +54,7 @@
 #include "tX_dial.h"
 #endif
 
-#ifdef USE_FLASH
 #include "tX_flash.h"
-#endif
 #include <stdio.h>
 
 #define WID_DYN TRUE, TRUE, 0
@@ -1254,11 +1252,9 @@ void update_all_vtts()
                if ((*vtt)->is_playing)
                {
                        gtk_tx_update_pos_display(GTK_TX((*vtt)->gui.display), (*vtt)->pos_i, (*vtt)->mute);
-#ifdef USE_FLASH
                        temp=(*vtt)->max_value*(*vtt)->res_volume*vtt_class::vol_channel_adjust;
                        (*vtt)->max_value=0;
                        gtk_tx_flash_set_level((*vtt)->gui.flash, temp);
-#endif         
                }
        }
 }
@@ -1266,10 +1262,8 @@ void update_all_vtts()
 void cleanup_vtt(vtt_class *vtt)
 {
                gtk_tx_cleanup_pos_display(GTK_TX(vtt->gui.display));   
-#ifdef USE_FLASH
                gtk_tx_flash_set_level(vtt->gui.flash, 0.0);
                gtk_tx_flash_clear(vtt->gui.flash);
-#endif         
 }
 
 void cleanup_all_vtts()
@@ -1279,10 +1273,8 @@ void cleanup_all_vtts()
        for (vtt=vtt_class::main_list.begin(); vtt!=vtt_class::main_list.end(); vtt++)
        {
                if ((*vtt)->buffer) gtk_tx_cleanup_pos_display(GTK_TX((*vtt)->gui.display));
-#ifdef USE_FLASH
                gtk_tx_flash_set_level((*vtt)->gui.flash, 0.0);
                gtk_tx_flash_clear((*vtt)->gui.flash);
-#endif         
        }
 }
 
index 06401e2b90d94ddb431703de130611d0b16704ac..f89de78642123a22de98cf28ddd52cb73f71067f 100644 (file)
 #include <list>
 #include "tX_seqpar.h"
 
-
-#ifdef DONT_USE_FLASH
-#undef USE_FLASH
-#else
-#define USE_FLASH 1
-#endif
-
 typedef struct vtt_gui
 {
        GtkWidget *control_box;
@@ -75,8 +68,8 @@ typedef struct vtt_gui
        GtkAdjustment *pitch;
        GtkAdjustment *pan;
        GtkAdjustment *volume; 
-    GtkWidget *mute;
-    GtkWidget *solo;
+       GtkWidget *mute;
+       GtkWidget *solo;
        GtkWidget *flash;
 
        /* Widgets in Lowpass Panel */