* ./po/*: re-ran make update-po, fixed a few translations.
[vlc.git] / plugins / motion / motion3dnow.c
1 /*****************************************************************************
2  * motion3dnow.c : 3D Now! motion compensation module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: motion3dnow.c,v 1.9 2002/04/21 10:32:20 sam Exp $
6  *
7  * Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
8  *          Michel Lespinasse <walken@zoy.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>                                      /* malloc(), free() */
29 #include <string.h>
30
31 #include <videolan/vlc.h>
32
33 #include "mmx.h"
34
35 /*****************************************************************************
36  * Local and extern prototypes.
37  *****************************************************************************/
38 static void motion_getfunctions( function_list_t * p_function_list );
39
40 /*****************************************************************************
41  * Build configuration tree.
42  *****************************************************************************/
43 MODULE_CONFIG_START
44 MODULE_CONFIG_STOP
45
46 MODULE_INIT_START
47     SET_DESCRIPTION( _("3D Now! motion compensation module") )
48     ADD_CAPABILITY( MOTION, 150 )
49     ADD_REQUIREMENT( 3DNOW )
50     ADD_SHORTCUT( "3dn" )
51     ADD_SHORTCUT( "3dnow" )
52     ADD_SHORTCUT( "motion3dn" )
53 MODULE_INIT_STOP
54
55 MODULE_ACTIVATE_START
56     motion_getfunctions( &p_module->p_functions->motion );
57 MODULE_ACTIVATE_STOP
58
59 MODULE_DEACTIVATE_START
60 MODULE_DEACTIVATE_STOP
61
62 /*****************************************************************************
63  * Motion compensation in 3D Now! (OK I know this does MMXEXT too and it's ugly)
64  *****************************************************************************/
65
66 #define CPU_MMXEXT 0
67 #define CPU_3DNOW 1
68
69
70 //CPU_MMXEXT/CPU_3DNOW adaptation layer
71
72 #define pavg_r2r(src,dest)                                                  \
73 do {                                                                        \
74     if (cpu == CPU_MMXEXT)                                                  \
75         pavgb_r2r (src, dest);                                              \
76     else                                                                    \
77         pavgusb_r2r (src, dest);                                            \
78 } while (0)
79
80 #define pavg_m2r(src,dest)                                                  \
81 do {                                                                        \
82     if (cpu == CPU_MMXEXT)                                                  \
83         pavgb_m2r (src, dest);                                              \
84     else                                                                    \
85         pavgusb_m2r (src, dest);                                            \
86 } while (0)
87
88
89 //CPU_MMXEXT code
90
91
92 static __inline__ void MC_put1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
93                               int stride)
94 {
95     do {
96         movq_m2r (*ref, mm0);
97         movq_r2m (mm0, *dest);
98         ref += stride;
99         dest += stride;
100     } while (--height);
101 }
102
103 static __inline__ void MC_put1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
104                                int stride)
105 {
106     do {
107         movq_m2r (*ref, mm0);
108         movq_m2r (*(ref+8), mm1);
109         ref += stride;
110         movq_r2m (mm0, *dest);
111         movq_r2m (mm1, *(dest+8));
112         dest += stride;
113     } while (--height);
114 }
115
116 static __inline__ void MC_avg1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
117                               int stride, int cpu)
118 {
119     do {
120         movq_m2r (*ref, mm0);
121         pavg_m2r (*dest, mm0);
122         ref += stride;
123         movq_r2m (mm0, *dest);
124         dest += stride;
125     } while (--height);
126 }
127
128 static __inline__ void MC_avg1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
129                                int stride, int cpu)
130 {
131     do {
132         movq_m2r (*ref, mm0);
133         movq_m2r (*(ref+8), mm1);
134         pavg_m2r (*dest, mm0);
135         pavg_m2r (*(dest+8), mm1);
136         movq_r2m (mm0, *dest);
137         ref += stride;
138         movq_r2m (mm1, *(dest+8));
139         dest += stride;
140     } while (--height);
141 }
142
143 static __inline__ void MC_put2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
144                               int stride, int offset, int cpu)
145 {
146     do {
147         movq_m2r (*ref, mm0);
148         pavg_m2r (*(ref+offset), mm0);
149         ref += stride;
150         movq_r2m (mm0, *dest);
151         dest += stride;
152     } while (--height);
153 }
154
155 static __inline__ void MC_put2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
156                                int stride, int offset, int cpu)
157 {
158     do {
159         movq_m2r (*ref, mm0);
160         movq_m2r (*(ref+8), mm1);
161         pavg_m2r (*(ref+offset), mm0);
162         pavg_m2r (*(ref+offset+8), mm1);
163         movq_r2m (mm0, *dest);
164         ref += stride;
165         movq_r2m (mm1, *(dest+8));
166         dest += stride;
167     } while (--height);
168 }
169
170 static __inline__ void MC_avg2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
171                               int stride, int offset, int cpu)
172 {
173     do {
174         movq_m2r (*ref, mm0);
175         pavg_m2r (*(ref+offset), mm0);
176         pavg_m2r (*dest, mm0);
177         ref += stride;
178         movq_r2m (mm0, *dest);
179         dest += stride;
180     } while (--height);
181 }
182
183 static __inline__ void MC_avg2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
184                                int stride, int offset, int cpu)
185 {
186     do {
187         movq_m2r (*ref, mm0);
188         movq_m2r (*(ref+8), mm1);
189         pavg_m2r (*(ref+offset), mm0);
190         pavg_m2r (*(ref+offset+8), mm1);
191         pavg_m2r (*dest, mm0);
192         pavg_m2r (*(dest+8), mm1);
193         ref += stride;
194         movq_r2m (mm0, *dest);
195         movq_r2m (mm1, *(dest+8));
196         dest += stride;
197     } while (--height);
198 }
199
200 static mmx_t mask_one = {0x0101010101010101LL};
201
202 static __inline__ void MC_put4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
203                               int stride, int cpu)
204 {
205     movq_m2r (*ref, mm0);
206     movq_m2r (*(ref+1), mm1);
207     movq_r2r (mm0, mm7);
208     pxor_r2r (mm1, mm7);
209     pavg_r2r (mm1, mm0);
210     ref += stride;
211
212     do {
213         movq_m2r (*ref, mm2);
214         movq_r2r (mm0, mm5);
215
216         movq_m2r (*(ref+1), mm3);
217         movq_r2r (mm2, mm6);
218
219         pxor_r2r (mm3, mm6);
220         pavg_r2r (mm3, mm2);
221
222         por_r2r (mm6, mm7);
223         pxor_r2r (mm2, mm5);
224
225         pand_r2r (mm5, mm7);
226         pavg_r2r (mm2, mm0);
227
228         pand_m2r (mask_one, mm7);
229
230         psubusb_r2r (mm7, mm0);
231
232         ref += stride;
233         movq_r2m (mm0, *dest);
234         dest += stride;
235
236         movq_r2r (mm6, mm7);        // unroll !
237         movq_r2r (mm2, mm0);        // unroll !
238     } while (--height);
239 }
240
241 static __inline__ void MC_put4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
242                                int stride, int cpu)
243 {
244     do {
245         movq_m2r (*ref, mm0);
246         movq_m2r (*(ref+stride+1), mm1);
247         movq_r2r (mm0, mm7);
248         movq_m2r (*(ref+1), mm2);
249         pxor_r2r (mm1, mm7);
250         movq_m2r (*(ref+stride), mm3);
251         movq_r2r (mm2, mm6);
252         pxor_r2r (mm3, mm6);
253         pavg_r2r (mm1, mm0);
254         pavg_r2r (mm3, mm2);
255         por_r2r (mm6, mm7);
256         movq_r2r (mm0, mm6);
257         pxor_r2r (mm2, mm6);
258         pand_r2r (mm6, mm7);
259         pand_m2r (mask_one, mm7);
260         pavg_r2r (mm2, mm0);
261         psubusb_r2r (mm7, mm0);
262         movq_r2m (mm0, *dest);
263
264         movq_m2r (*(ref+8), mm0);
265         movq_m2r (*(ref+stride+9), mm1);
266         movq_r2r (mm0, mm7);
267         movq_m2r (*(ref+9), mm2);
268         pxor_r2r (mm1, mm7);
269         movq_m2r (*(ref+stride+8), mm3);
270         movq_r2r (mm2, mm6);
271         pxor_r2r (mm3, mm6);
272         pavg_r2r (mm1, mm0);
273         pavg_r2r (mm3, mm2);
274         por_r2r (mm6, mm7);
275         movq_r2r (mm0, mm6);
276         pxor_r2r (mm2, mm6);
277         pand_r2r (mm6, mm7);
278         pand_m2r (mask_one, mm7);
279         pavg_r2r (mm2, mm0);
280         psubusb_r2r (mm7, mm0);
281         ref += stride;
282         movq_r2m (mm0, *(dest+8));
283         dest += stride;
284     } while (--height);
285 }
286
287 static __inline__ void MC_avg4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
288                               int stride, int cpu)
289 {
290     do {
291         movq_m2r (*ref, mm0);
292         movq_m2r (*(ref+stride+1), mm1);
293         movq_r2r (mm0, mm7);
294         movq_m2r (*(ref+1), mm2);
295         pxor_r2r (mm1, mm7);
296         movq_m2r (*(ref+stride), mm3);
297         movq_r2r (mm2, mm6);
298         pxor_r2r (mm3, mm6);
299         pavg_r2r (mm1, mm0);
300         pavg_r2r (mm3, mm2);
301         por_r2r (mm6, mm7);
302         movq_r2r (mm0, mm6);
303         pxor_r2r (mm2, mm6);
304         pand_r2r (mm6, mm7);
305         pand_m2r (mask_one, mm7);
306         pavg_r2r (mm2, mm0);
307         psubusb_r2r (mm7, mm0);
308         movq_m2r (*dest, mm1);
309         pavg_r2r (mm1, mm0);
310         ref += stride;
311         movq_r2m (mm0, *dest);
312         dest += stride;
313     } while (--height);
314 }
315
316 static __inline__ void MC_avg4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
317                                int stride, int cpu)
318 {
319     do {
320         movq_m2r (*ref, mm0);
321         movq_m2r (*(ref+stride+1), mm1);
322         movq_r2r (mm0, mm7);
323         movq_m2r (*(ref+1), mm2);
324         pxor_r2r (mm1, mm7);
325         movq_m2r (*(ref+stride), mm3);
326         movq_r2r (mm2, mm6);
327         pxor_r2r (mm3, mm6);
328         pavg_r2r (mm1, mm0);
329         pavg_r2r (mm3, mm2);
330         por_r2r (mm6, mm7);
331         movq_r2r (mm0, mm6);
332         pxor_r2r (mm2, mm6);
333         pand_r2r (mm6, mm7);
334         pand_m2r (mask_one, mm7);
335         pavg_r2r (mm2, mm0);
336         psubusb_r2r (mm7, mm0);
337         movq_m2r (*dest, mm1);
338         pavg_r2r (mm1, mm0);
339         movq_r2m (mm0, *dest);
340
341         movq_m2r (*(ref+8), mm0);
342         movq_m2r (*(ref+stride+9), mm1);
343         movq_r2r (mm0, mm7);
344         movq_m2r (*(ref+9), mm2);
345         pxor_r2r (mm1, mm7);
346         movq_m2r (*(ref+stride+8), mm3);
347         movq_r2r (mm2, mm6);
348         pxor_r2r (mm3, mm6);
349         pavg_r2r (mm1, mm0);
350         pavg_r2r (mm3, mm2);
351         por_r2r (mm6, mm7);
352         movq_r2r (mm0, mm6);
353         pxor_r2r (mm2, mm6);
354         pand_r2r (mm6, mm7);
355         pand_m2r (mask_one, mm7);
356         pavg_r2r (mm2, mm0);
357         psubusb_r2r (mm7, mm0);
358         movq_m2r (*(dest+8), mm1);
359         pavg_r2r (mm1, mm0);
360         ref += stride;
361         movq_r2m (mm0, *(dest+8));
362         dest += stride;
363     } while (--height);
364 }
365
366 static void MC_avg_16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
367                               int stride, int height)
368 {
369     MC_avg1_16 (height, dest, ref, stride, CPU_MMXEXT);
370 }
371
372 static void MC_avg_8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
373                              int stride, int height)
374 {
375     MC_avg1_8 (height, dest, ref, stride, CPU_MMXEXT);
376 }
377
378 static void MC_put_16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
379                               int stride, int height)
380 {
381     MC_put1_16 (height, dest, ref, stride);
382 }
383
384 static void MC_put_8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
385                              int stride, int height)
386 {
387     MC_put1_8 (height, dest, ref, stride);
388 }
389
390 static void MC_avg_x16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
391                                int stride, int height)
392 {
393     MC_avg2_16 (height, dest, ref, stride, 1, CPU_MMXEXT);
394 }
395
396 static void MC_avg_x8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
397                               int stride, int height)
398 {
399     MC_avg2_8 (height, dest, ref, stride, 1, CPU_MMXEXT);
400 }
401
402 static void MC_put_x16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
403                                int stride, int height)
404 {
405     MC_put2_16 (height, dest, ref, stride, 1, CPU_MMXEXT);
406 }
407
408 static void MC_put_x8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
409                               int stride, int height)
410 {
411     MC_put2_8 (height, dest, ref, stride, 1, CPU_MMXEXT);
412 }
413
414 static void MC_avg_y16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
415                                int stride, int height)
416 {
417     MC_avg2_16 (height, dest, ref, stride, stride, CPU_MMXEXT);
418 }
419
420 static void MC_avg_y8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
421                               int stride, int height)
422 {
423     MC_avg2_8 (height, dest, ref, stride, stride, CPU_MMXEXT);
424 }
425
426 static void MC_put_y16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
427                                int stride, int height)
428 {
429     MC_put2_16 (height, dest, ref, stride, stride, CPU_MMXEXT);
430 }
431
432 static void MC_put_y8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
433                               int stride, int height)
434 {
435     MC_put2_8 (height, dest, ref, stride, stride, CPU_MMXEXT);
436 }
437
438 static void MC_avg_xy16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
439                                 int stride, int height)
440 {
441     MC_avg4_16 (height, dest, ref, stride, CPU_MMXEXT);
442 }
443
444 static void MC_avg_xy8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
445                                int stride, int height)
446 {
447     MC_avg4_8 (height, dest, ref, stride, CPU_MMXEXT);
448 }
449
450 static void MC_put_xy16_mmxext (yuv_data_t * dest, yuv_data_t * ref,
451                                 int stride, int height)
452 {
453     MC_put4_16 (height, dest, ref, stride, CPU_MMXEXT);
454 }
455
456 static void MC_put_xy8_mmxext (yuv_data_t * dest, yuv_data_t * ref,
457                                int stride, int height)
458 {
459     MC_put4_8 (height, dest, ref, stride, CPU_MMXEXT);
460 }
461
462
463 static void MC_avg_16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
464                               int stride, int height)
465 {
466     MC_avg1_16 (height, dest, ref, stride, CPU_3DNOW);
467 }
468
469 static void MC_avg_8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
470                              int stride, int height)
471 {
472     MC_avg1_8 (height, dest, ref, stride, CPU_3DNOW);
473 }
474
475 static void MC_put_16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
476                               int stride, int height)
477 {
478     MC_put1_16 (height, dest, ref, stride);
479 }
480
481 static void MC_put_8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
482                              int stride, int height)
483 {
484     MC_put1_8 (height, dest, ref, stride);
485 }
486
487 static void MC_avg_x16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
488                                int stride, int height)
489 {
490     MC_avg2_16 (height, dest, ref, stride, 1, CPU_3DNOW);
491 }
492
493 static void MC_avg_x8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
494                               int stride, int height)
495 {
496     MC_avg2_8 (height, dest, ref, stride, 1, CPU_3DNOW);
497 }
498
499 static void MC_put_x16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
500                                int stride, int height)
501 {
502     MC_put2_16 (height, dest, ref, stride, 1, CPU_3DNOW);
503 }
504
505 static void MC_put_x8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
506                               int stride, int height)
507 {
508     MC_put2_8 (height, dest, ref, stride, 1, CPU_3DNOW);
509 }
510
511 static void MC_avg_y16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
512                                int stride, int height)
513 {
514     MC_avg2_16 (height, dest, ref, stride, stride, CPU_3DNOW);
515 }
516
517 static void MC_avg_y8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
518                               int stride, int height)
519 {
520     MC_avg2_8 (height, dest, ref, stride, stride, CPU_3DNOW);
521 }
522
523 static void MC_put_y16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
524                                int stride, int height)
525 {
526     MC_put2_16 (height, dest, ref, stride, stride, CPU_3DNOW);
527 }
528
529 static void MC_put_y8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
530                               int stride, int height)
531 {
532     MC_put2_8 (height, dest, ref, stride, stride, CPU_3DNOW);
533 }
534
535 static void MC_avg_xy16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
536                                 int stride, int height)
537 {
538     MC_avg4_16 (height, dest, ref, stride, CPU_3DNOW);
539 }
540
541 static void MC_avg_xy8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
542                                int stride, int height)
543 {
544     MC_avg4_8 (height, dest, ref, stride, CPU_3DNOW);
545 }
546
547 static void MC_put_xy16_3dnow (yuv_data_t * dest, yuv_data_t * ref,
548                                 int stride, int height)
549 {
550     MC_put4_16 (height, dest, ref, stride, CPU_3DNOW);
551 }
552
553 static void MC_put_xy8_3dnow (yuv_data_t * dest, yuv_data_t * ref,
554                                int stride, int height)
555 {
556     MC_put4_8 (height, dest, ref, stride, CPU_3DNOW);
557 }
558
559 /*****************************************************************************
560  * Functions exported as capabilities. They are declared as static so that
561  * we don't pollute the namespace too much.
562  *****************************************************************************/
563 static void motion_getfunctions( function_list_t * p_function_list )
564 {
565     static void (* ppppf_motion[2][2][4])( yuv_data_t *, yuv_data_t *,
566                                            int, int ) =
567     {
568         {
569             /* Copying functions */
570             {
571                 /* Width == 16 */
572                 MC_put_16_3dnow, MC_put_x16_3dnow, MC_put_y16_3dnow, MC_put_xy16_3dnow
573             },
574             {
575                 /* Width == 8 */
576                 MC_put_8_3dnow,  MC_put_x8_3dnow,  MC_put_y8_3dnow, MC_put_xy8_3dnow
577             }
578         },
579         {
580             /* Averaging functions */
581             {
582                 /* Width == 16 */
583                 MC_avg_16_3dnow, MC_avg_x16_3dnow, MC_avg_y16_3dnow, MC_avg_xy16_3dnow
584             },
585             {
586                 /* Width == 8 */
587                 MC_avg_8_3dnow,  MC_avg_x8_3dnow,  MC_avg_y8_3dnow,  MC_avg_xy8_3dnow
588             }
589         }
590     };
591
592 #define list p_function_list->functions.motion
593     memcpy( list.ppppf_motion, ppppf_motion, sizeof( void * ) * 16 );
594 #undef list
595
596     return;
597 }
598