Mercurial > mplayer.hg
annotate libvo/aclib.c @ 22884:3f571edb7550
restored previous definition of -mpegopts :drop and :tsaf (r22900); they were there for a good reason
author | nicodvb |
---|---|
date | Sun, 01 Apr 2007 21:54:18 +0000 |
parents | fa66a03e8920 |
children | 273aa6124f66 |
rev | line source |
---|---|
12650
ac3fd2ff2561
Unify the config.h #include, use "config.h" instead of "../config.h"
diego
parents:
12492
diff
changeset
|
1 #include "config.h" |
3393 | 2 #ifdef USE_FASTMEMCPY |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
3 |
3077
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
4 /* |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
5 aclib - advanced C library ;) |
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
6 This file contains functions which improve and expand standard C-library |
3393 | 7 see aclib_template.c ... this file only contains runtime cpu detection and config options stuff |
8 runtime cpu detection by michael niedermayer (michaelni@gmx.at) is under GPL | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
9 */ |
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
10 #include <stddef.h> |
21982
fa66a03e8920
Include string.h to make sure memcpy is not used without prototype
reimar
parents:
20577
diff
changeset
|
11 #include <string.h> |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
13720
diff
changeset
|
12 #include "cpudetect.h" |
8123
9fc45fe0d444
*HUGE* set of compiler warning fixes, unused variables removal
arpi
parents:
7072
diff
changeset
|
13 #include "fastmemcpy.h" |
12492
4b8417674f1c
fix crash due to fast_memcpy calling itself instead of libc memcpy
reimar
parents:
8127
diff
changeset
|
14 #undef memcpy |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
15 |
3077
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
16 #define BLOCK_SIZE 4096 |
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
17 #define CONFUSION_FACTOR 0 |
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
18 //Feel free to fine-tune the above 2, it might be possible to get some speedup with them :) |
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
19 |
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
20 //#define STATISTICS |
20577 | 21 #ifdef ARCH_X86 |
3393 | 22 #define CAN_COMPILE_X86_ASM |
23 #endif | |
24 | |
25 //Note: we have MMX, MMX2, 3DNOW version there is no 3DNOW+MMX2 one | |
26 //Plain C versions | |
27 //#if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT) | |
28 //#define COMPILE_C | |
29 //#endif | |
30 | |
31 #ifdef CAN_COMPILE_X86_ASM | |
32 | |
33 #if (defined (HAVE_MMX) && !defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT) | |
34 #define COMPILE_MMX | |
35 #endif | |
36 | |
5208 | 37 #if (defined (HAVE_MMX2) && !defined (HAVE_SSE2)) || defined (RUNTIME_CPUDETECT) |
3393 | 38 #define COMPILE_MMX2 |
39 #endif | |
40 | |
41 #if (defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT) | |
42 #define COMPILE_3DNOW | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
43 #endif |
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
44 |
5208 | 45 #if defined (HAVE_SSE2) || defined (RUNTIME_CPUDETECT) |
46 #define COMPILE_SSE | |
47 #endif | |
48 | |
3393 | 49 #undef HAVE_MMX |
50 #undef HAVE_MMX2 | |
51 #undef HAVE_3DNOW | |
5208 | 52 #undef HAVE_SSE |
53 #undef HAVE_SSE2 | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
54 /* |
3393 | 55 #ifdef COMPILE_C |
56 #undef HAVE_MMX | |
57 #undef HAVE_MMX2 | |
58 #undef HAVE_3DNOW | |
59 #undef ARCH_X86 | |
60 #define RENAME(a) a ## _C | |
61 #include "aclib_template.c" | |
62 #endif | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
63 */ |
3393 | 64 //MMX versions |
65 #ifdef COMPILE_MMX | |
66 #undef RENAME | |
67 #define HAVE_MMX | |
68 #undef HAVE_MMX2 | |
69 #undef HAVE_3DNOW | |
5208 | 70 #undef HAVE_SSE |
71 #undef HAVE_SSE2 | |
3393 | 72 #define RENAME(a) a ## _MMX |
73 #include "aclib_template.c" | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
74 #endif |
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
75 |
3393 | 76 //MMX2 versions |
77 #ifdef COMPILE_MMX2 | |
78 #undef RENAME | |
79 #define HAVE_MMX | |
80 #define HAVE_MMX2 | |
81 #undef HAVE_3DNOW | |
5208 | 82 #undef HAVE_SSE |
83 #undef HAVE_SSE2 | |
3393 | 84 #define RENAME(a) a ## _MMX2 |
85 #include "aclib_template.c" | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
86 #endif |
3077
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
87 |
3393 | 88 //3DNOW versions |
89 #ifdef COMPILE_3DNOW | |
90 #undef RENAME | |
91 #define HAVE_MMX | |
92 #undef HAVE_MMX2 | |
93 #define HAVE_3DNOW | |
5208 | 94 #undef HAVE_SSE |
95 #undef HAVE_SSE2 | |
3393 | 96 #define RENAME(a) a ## _3DNow |
97 #include "aclib_template.c" | |
3077
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
98 #endif |
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
99 |
5208 | 100 //SSE versions (only used on SSE2 cpus) |
101 #ifdef COMPILE_SSE | |
102 #undef RENAME | |
103 #define HAVE_MMX | |
104 #define HAVE_MMX2 | |
105 #undef HAVE_3DNOW | |
106 #define HAVE_SSE | |
107 #define HAVE_SSE2 | |
108 #define RENAME(a) a ## _SSE | |
109 #include "aclib_template.c" | |
110 #endif | |
111 | |
3393 | 112 #endif // CAN_COMPILE_X86_ASM |
113 | |
3077
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
114 |
7072 | 115 void * fast_memcpy(void * to, const void * from, size_t len) |
3393 | 116 { |
117 #ifdef RUNTIME_CPUDETECT | |
118 #ifdef CAN_COMPILE_X86_ASM | |
119 // ordered per speed fasterst first | |
5208 | 120 if(gCpuCaps.hasSSE2) |
121 fast_memcpy_SSE(to, from, len); | |
122 else if(gCpuCaps.hasMMX2) | |
3393 | 123 fast_memcpy_MMX2(to, from, len); |
124 else if(gCpuCaps.has3DNow) | |
125 fast_memcpy_3DNow(to, from, len); | |
126 else if(gCpuCaps.hasMMX) | |
127 fast_memcpy_MMX(to, from, len); | |
128 else | |
129 #endif //CAN_COMPILE_X86_ASM | |
130 memcpy(to, from, len); // prior to mmx we use the standart memcpy | |
131 #else | |
5208 | 132 #ifdef HAVE_SSE2 |
133 fast_memcpy_SSE(to, from, len); | |
134 #elif defined (HAVE_MMX2) | |
3393 | 135 fast_memcpy_MMX2(to, from, len); |
136 #elif defined (HAVE_3DNOW) | |
137 fast_memcpy_3DNow(to, from, len); | |
138 #elif defined (HAVE_MMX) | |
139 fast_memcpy_MMX(to, from, len); | |
140 #else | |
141 memcpy(to, from, len); // prior to mmx we use the standart memcpy | |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
142 #endif |
3077
99f6db3255aa
10-20% faster fastmemcpy :) on my p3 at least but the algo is mostly from "amd athlon processor x86 code optimization guide" so it should be faster for amd chips too, but i fear it might be slower for mem->vram copies (someone should check that, i cant) ... there are 2 #defines to finetune it (BLOCK_SIZE & CONFUSION_FACTOR)
michael
parents:
1123
diff
changeset
|
143 |
3393 | 144 #endif //!RUNTIME_CPUDETECT |
5543
c75f75806af1
memcpy must return destination ptr patch by Adam <adam@cfar.umd.edu>
michael
parents:
5208
diff
changeset
|
145 return to; |
698
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
146 } |
f0fbf1a9bf31
Moving fast_memcpy to separate file (Size optimization)
nickols_k
parents:
diff
changeset
|
147 |
8127
e7153e62a7f4
On non-x86 platforms, memcpy was re-implemented in mplayer and was called
jkeil
parents:
8123
diff
changeset
|
148 #undef mem2agpcpy |
7072 | 149 void * mem2agpcpy(void * to, const void * from, size_t len) |
4681 | 150 { |
151 #ifdef RUNTIME_CPUDETECT | |
152 #ifdef CAN_COMPILE_X86_ASM | |
153 // ordered per speed fasterst first | |
5208 | 154 if(gCpuCaps.hasSSE2) |
155 mem2agpcpy_SSE(to, from, len); | |
156 else if(gCpuCaps.hasMMX2) | |
4681 | 157 mem2agpcpy_MMX2(to, from, len); |
158 else if(gCpuCaps.has3DNow) | |
159 mem2agpcpy_3DNow(to, from, len); | |
160 else if(gCpuCaps.hasMMX) | |
161 mem2agpcpy_MMX(to, from, len); | |
162 else | |
163 #endif //CAN_COMPILE_X86_ASM | |
164 memcpy(to, from, len); // prior to mmx we use the standart memcpy | |
165 #else | |
5208 | 166 #ifdef HAVE_SSE2 |
167 mem2agpcpy_SSE(to, from, len); | |
168 #elif defined (HAVE_MMX2) | |
4681 | 169 mem2agpcpy_MMX2(to, from, len); |
170 #elif defined (HAVE_3DNOW) | |
171 mem2agpcpy_3DNow(to, from, len); | |
172 #elif defined (HAVE_MMX) | |
173 mem2agpcpy_MMX(to, from, len); | |
174 #else | |
175 memcpy(to, from, len); // prior to mmx we use the standart memcpy | |
176 #endif | |
177 | |
178 #endif //!RUNTIME_CPUDETECT | |
8123
9fc45fe0d444
*HUGE* set of compiler warning fixes, unused variables removal
arpi
parents:
7072
diff
changeset
|
179 return to; |
4681 | 180 } |
181 | |
182 #endif /* use fastmemcpy */ | |
183 |