← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/mpeg2enc/predcomp_mmxe.cc

  • Committer: Bazaar Package Importer
  • Author(s): Matvey Kozhev
  • Date: 2007-12-18 13:53:04 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071218135304-cdqec2lg2bglyz15
Tags: 1:2.4~preview3-0.0ubuntu1
https://launchpad.net/bugs/163287
https://launchpad.net/bugs/126572
https://launchpad.net/bugs/138854
* Upload to Ubuntu. (LP: #163287, LP: #126572)
* debian/changelog: re-added Ubuntu releases.
* debian/control:
  - Require debhelper >= 5.0.51 (for dh_icons) and imagemagick.
  - Build-depend on libsdl1.2-dev instead of libsdl-dev.
  - Build against newer libx264-dev. (LP: #138854)
  - Removed libamrnb-dev, not in Ubuntu yet.
* debian/rules:
  - Install all icon sizes, using convert (upstream installs none).
  - Added missing calls to dh_installmenu, dh_installman, dh_icons and
    dh_desktop.
* debian/menu, debian/avidemux-qt.menu:
  - Corrected package and executable names.
* debian/avidemux-common.install: Install icons.
* debian/avidemux.common.manpages: Install man/avidemux.1.
* debian/links, debian/avidemux-cli.links, debian/avidemux-gtk.links:
  - Link manpages to avidemux.1.gz.
* debian/install, debian/avidemux-qt.install, debian/avidemux-gtk.desktop,
  debian/avidemux-qt.desktop: Install desktop files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/mpeg2enc/predcomp_mmxe.cc
1
 
/*
2
 
 *   predcomp_00_mmxe.s:
3
 
 * 
4
 
 *                Extended MMX prediction composition
5
 
 *   routines handling the four different interpolation cases...
6
 
 *  
7
 
 *   Copyright (C) 2000 Andrew Stevens <as@comlab.ox.ac.uk>
8
 
 * 
9
 
 * 
10
 
 *   This program is free software; you can reaxstribute it and/or
11
 
 *   modify it under the terms of the GNU General Public License
12
 
 *   as published by the Free Software Foundation; either version 2
13
 
 *   of the License, or (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
23
 
 *   02111-1307, USA.
24
 
 */
25
 
 
26
 
#include <config.h>
27
 
#if defined( ARCH_X86)  || defined(ARCH_X86_64)
28
 
#include "mjpeg_types.h"
29
 
#include "mmx.h"
30
 
 
31
 
/* 
32
 
 * void predcomp_<ix><iy>_mmxe(char *src,char *dst,int lx, int w, int h, int mask);
33
 
 * 
34
 
 * ix - Interpolation in x iy - Interpolation in y
35
 
 *              
36
 
 */
37
 
 
38
 
 
39
 
/* The no interpolation case... */
40
 
 
41
 
void predcomp_00_mmxe(char *src,char *dst,int lx, int w, int h, int mask)
42
 
{
43
 
        movd_g2r(mask, mm0);
44
 
        pxor_r2r(mm2, mm2);
45
 
        punpckldq_r2r(mm0, mm0);
46
 
        pcmpeqd_r2r(mm2, mm0);
47
 
        movq_r2r(mm0, mm1);     
48
 
        pcmpeqd_r2r(mm2, mm0);
49
 
        
50
 
        do {
51
 
                movq_m2r(*src, mm4); /* first 8 bytes of row */
52
 
                movq_m2r(*dst, mm2);
53
 
                pand_r2r(mm0, mm2);
54
 
                movq_r2r(mm4, mm3);
55
 
                pand_r2r(mm1, mm3);
56
 
                por_r2r(mm3, mm2);
57
 
                pavgb_r2r(mm2, mm4);
58
 
                movq_r2m(mm4, *dst);
59
 
                
60
 
                if (w != 8)
61
 
                {
62
 
                        movq_m2r(*(src+8), mm4); /* first 8 bytes of row */
63
 
                        movq_m2r(*(dst+8), mm2);
64
 
                        pand_r2r(mm0, mm2);
65
 
                        movq_r2r(mm4, mm3);
66
 
                        pand_r2r(mm1, mm3);
67
 
                        por_r2r(mm3, mm2);
68
 
                        pavgb_r2r(mm2, mm4);
69
 
                        movq_r2m(mm4, *(dst+8));                
70
 
                }
71
 
 
72
 
                dst += lx;
73
 
                src += lx;
74
 
                
75
 
                h--;    
76
 
        } while (h);
77
 
        
78
 
        emms();
79
 
}
80
 
 
81
 
 
82
 
/* The x-axis interpolation case... */
83
 
 
84
 
void predcomp_10_mmxe(char *src,char *dst,int lx, int w, int h, int mask)
85
 
{
86
 
        movd_g2r(mask, mm0);
87
 
        pxor_r2r(mm2, mm2);
88
 
        punpckldq_r2r(mm0, mm0);
89
 
        pcmpeqd_r2r(mm2, mm0);
90
 
        movq_r2r(mm0, mm1);     
91
 
        pcmpeqd_r2r(mm2, mm0);
92
 
                
93
 
        do {
94
 
                movq_m2r(*src, mm4);      /* first 8 bytes row:  avg src in x */
95
 
                pavgb_m2r(*(src+1), mm4);
96
 
                movq_m2r(*dst, mm2);    
97
 
                pand_r2r(mm0, mm2);
98
 
                movq_r2r(mm4, mm3);
99
 
                pand_r2r(mm1, mm3);
100
 
                por_r2r(mm3, mm2);
101
 
                pavgb_r2r(mm2, mm4); /* combine */
102
 
                movq_r2m(mm4, *dst);
103
 
                
104
 
                if (w != 8)
105
 
                {
106
 
                        movq_m2r(*(src+8), mm4);          /* first 8 bytes row:  avg src in x */
107
 
                        pavgb_m2r(*(src+9), mm4);
108
 
                        movq_m2r(*(dst+8), mm2);        
109
 
                        pand_r2r(mm0, mm2);
110
 
                        movq_r2r(mm4, mm3);
111
 
                        pand_r2r(mm1, mm3);
112
 
                        por_r2r(mm3, mm2);
113
 
                        pavgb_r2r(mm2, mm4); /* combine */
114
 
                        movq_r2m(mm4, *(dst+8));                
115
 
                }               
116
 
                
117
 
                dst += lx;
118
 
                src += lx;              
119
 
                
120
 
                h--;
121
 
        } while (h);
122
 
        
123
 
        emms();
124
 
}
125
 
 
126
 
 
127
 
 
128
 
/* The x-axis and y-axis interpolation case... */
129
 
                
130
 
void predcomp_11_mmxe(char *src,char *dst,int lx, int w, int h, int mask)
131
 
{
132
 
 
133
 
        /* mm2 = [0,0,0,0]W */
134
 
        /* mm3 = [2,2,2,2]W */
135
 
 
136
 
        movd_g2r(0x00020002, mm3);
137
 
        punpckldq_r2r(mm3, mm3);
138
 
        
139
 
        movd_g2r(mask, mm0);    
140
 
        pxor_r2r(mm2, mm2);
141
 
        punpckldq_r2r(mm0, mm0);
142
 
        pcmpeqd_r2r(mm2, mm0);
143
 
        movq_r2r(mm0, mm1);
144
 
        pcmpeqd_r2r(mm2, mm0);
145
 
 
146
 
        do {
147
 
                movq_m2r(*src, mm4); /*  mm4 and mm6 accumulate partial sums for interp. */
148
 
                movq_r2r(mm4, mm6);
149
 
                punpcklbw_r2r(mm2, mm4);
150
 
                punpckhbw_r2r(mm2, mm6);
151
 
                
152
 
                movq_m2r(*(src+1), mm5);
153
 
                movq_r2r(mm5, mm7);
154
 
                punpcklbw_r2r(mm2, mm5);
155
 
                paddw_r2r(mm5, mm4);
156
 
                punpckhbw_r2r(mm2, mm7);
157
 
                paddw_r2r(mm7, mm6);
158
 
 
159
 
                src += lx; 
160
 
                
161
 
                movq_m2r(*src, mm5); /* first 8 bytes 1st row:   avg src in x */
162
 
                movq_r2r(mm5, mm7);
163
 
                punpcklbw_r2r(mm2, mm5);
164
 
                paddw_r2r(mm5, mm4);
165
 
                punpckhbw_r2r(mm2, mm7);
166
 
                paddw_r2r(mm7, mm6);
167
 
 
168
 
                movq_m2r(*(src+1), mm5);
169
 
                movq_r2r(mm5, mm7);
170
 
                punpcklbw_r2r(mm2, mm5);
171
 
                paddw_r2r(mm5, mm4);
172
 
                punpckhbw_r2r(mm2, mm7);
173
 
                paddw_r2r(mm7, mm6);
174
 
                
175
 
                /* Now round and repack... */
176
 
                paddw_r2r(mm3, mm4);
177
 
                paddw_r2r(mm3, mm6);
178
 
                psrlw_i2r(2, mm4);
179
 
                psrlw_i2r(2, mm6);
180
 
                packuswb_r2r(mm6, mm4);
181
 
                
182
 
                movq_m2r(*dst, mm7);
183
 
                pand_r2r(mm0, mm7);
184
 
                movq_r2r(mm4, mm6);
185
 
                pand_r2r(mm1, mm6);
186
 
                por_r2r(mm6, mm7);
187
 
                pavgb_r2r(mm7, mm4);
188
 
                movq_r2m(mm4, *dst);
189
 
                
190
 
                if (w != 8)
191
 
                {
192
 
                        src -= lx; /* Back to 1st row */
193
 
 
194
 
                        movq_m2r(*(src+8), mm4); /*  mm4 and mm6 accumulate partial sums for interp. */
195
 
                        movq_r2r(mm4, mm6);
196
 
                        punpcklbw_r2r(mm2, mm4);
197
 
                        punpckhbw_r2r(mm2, mm6);
198
 
                
199
 
                        movq_m2r(*(src+9), mm5);
200
 
                        movq_r2r(mm5, mm7);
201
 
                        punpcklbw_r2r(mm2, mm5);
202
 
                        paddw_r2r(mm5, mm4);
203
 
                        punpckhbw_r2r(mm2, mm7);
204
 
                        paddw_r2r(mm7, mm6);
205
 
 
206
 
                        src += lx; 
207
 
                
208
 
                        movq_m2r(*(src+8), mm5); /* first 8 bytes 1st row:       avg src in x */
209
 
                        movq_r2r(mm5, mm7);
210
 
                        punpcklbw_r2r(mm2, mm5);
211
 
                        paddw_r2r(mm5, mm4);
212
 
                        punpckhbw_r2r(mm2, mm7);
213
 
                        paddw_r2r(mm7, mm6);
214
 
 
215
 
                        movq_m2r(*(src+9), mm5);
216
 
                        movq_r2r(mm5, mm7);
217
 
                        punpcklbw_r2r(mm2, mm5);
218
 
                        paddw_r2r(mm5, mm4);
219
 
                        punpckhbw_r2r(mm2, mm7);
220
 
                        paddw_r2r(mm7, mm6);
221
 
                
222
 
                        /* Now round and repack... */
223
 
                        paddw_r2r(mm3, mm4);
224
 
                        paddw_r2r(mm3, mm6);
225
 
                        psrlw_i2r(2, mm4);
226
 
                        psrlw_i2r(2, mm6);
227
 
                        packuswb_r2r(mm6, mm4);
228
 
                
229
 
                        movq_m2r(*(dst+8), mm7);
230
 
                        pand_r2r(mm0, mm7);
231
 
                        movq_r2r(mm4, mm6);
232
 
                        pand_r2r(mm1, mm6);
233
 
                        por_r2r(mm6, mm7);
234
 
                        pavgb_r2r(mm7, mm4);
235
 
                        movq_r2m(mm4, *(dst+8));
236
 
                }
237
 
                
238
 
                dst += lx; 
239
 
                                        
240
 
                h--;
241
 
        } while (h);
242
 
        
243
 
        emms(); 
244
 
}
245
 
 
246
 
 
247
 
/* The  y-axis interpolation case... */
248
 
 
249
 
void predcomp_01_mmxe(char *src,char *dst,int lx, int w, int h, int mask)
250
 
{
251
 
        movd_g2r(mask, mm0);    
252
 
        pxor_r2r(mm2, mm2);
253
 
        punpckldq_r2r(mm0, mm0);
254
 
        pcmpeqd_r2r(mm2, mm0);
255
 
        movq_r2r(mm0, mm1);
256
 
        pcmpeqd_r2r(mm2, mm0);
257
 
 
258
 
        do {
259
 
                movq_m2r(*src, mm4);    /* first 8 bytes row */
260
 
                src+=lx;                /*  update pointer to next row */
261
 
                pavgb_m2r(*src, mm4);   /* Average in y */
262
 
 
263
 
                movq_m2r(*dst, mm2);
264
 
                pand_r2r(mm0, mm2);
265
 
                movq_r2r(mm4, mm3);
266
 
                pand_r2r(mm1, mm3);
267
 
                por_r2r(mm3, mm2);
268
 
                pavgb_r2r(mm2, mm4);
269
 
                movq_r2m(mm4, *dst);
270
 
                
271
 
                if (w != 8)
272
 
                {
273
 
                        src-=lx;                  /* Back to prev row */
274
 
                        movq_m2r(*(src+8), mm4);  /* first 8 bytes row */
275
 
                        src+=lx;                  /*  update pointer to next row */
276
 
                        pavgb_m2r(*(src+8), mm4);  /* Average in y */
277
 
 
278
 
                        movq_m2r(*(dst+8), mm2);
279
 
                        pand_r2r(mm0, mm2);
280
 
                        movq_r2r(mm4, mm3);
281
 
                        pand_r2r(mm1, mm3);
282
 
                        por_r2r(mm3, mm2);
283
 
                        pavgb_r2r(mm2, mm4);
284
 
                        movq_r2m(mm4, *(dst+8));                        
285
 
                }
286
 
 
287
 
                dst+=lx;  /*  update pointer to next row */
288
 
 
289
 
                h--;
290
 
        } while (h);
291
 
        
292
 
        emms();
293
 
}
294
 
#endif