?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1009: Move the dependencies to newer package names
[cinelerra_cv/mob.git] / quicktime / rtjpeg_core.c
blob1b7441fe1027c58216e5a8e8f92d4e0b95f94191
1 /*
2 bttvgrab 0.15.4 [1999-03-23]
3 (c) 1998, 1999 by Joerg Walter <trouble@moes.pmnet.uni-oldenburg.de>
4
5 Maintained by: Joerg Walter
6 Current version at http:/*moes.pmnet.uni-oldenburg.de/bttvgrab/ */
7
8 This program is free software; you can rquantptr it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
22 This file is a modified version of RTjpeg 0.1.2, (C) Justin Schoeman 1998
23 */
24
25
26 /*
27
28 Main Routines
29
30 This file contains most of the initialisation and control functions
31
32 (C) Justin Schoeman 1998
33
34 */
35
36 #include <sys/types.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include "rtjpeg_core.h"
41
42 static const unsigned char RTjpeg_ZZ[64]={
43 0,
44 8, 1,
45 2, 9, 16,
46 24, 17, 10, 3,
47 4, 11, 18, 25, 32,
48 40, 33, 26, 19, 12, 5,
49 6, 13, 20, 27, 34, 41, 48,
50 56, 49, 42, 35, 28, 21, 14, 7,
51 15, 22, 29, 36, 43, 50, 57,
52 58, 51, 44, 37, 30, 23,
53 31, 38, 45, 52, 59,
54 60, 53, 46, 39,
55 47, 54, 61,
56 62, 55,
57 63 };
58
59 static const __u64 RTjpeg_aan_tab[64]={
60 4294967296ULL, 5957222912ULL, 5611718144ULL, 5050464768ULL, 4294967296ULL, 3374581504ULL, 2324432128ULL, 1184891264ULL,
61 5957222912ULL, 8263040512ULL, 7783580160ULL, 7005009920ULL, 5957222912ULL, 4680582144ULL, 3224107520ULL, 1643641088ULL,
62 5611718144ULL, 7783580160ULL, 7331904512ULL, 6598688768ULL, 5611718144ULL, 4408998912ULL, 3036936960ULL, 1548224000ULL,
63 5050464768ULL, 7005009920ULL, 6598688768ULL, 5938608128ULL, 5050464768ULL, 3968072960ULL, 2733115392ULL, 1393296000ULL,
64 4294967296ULL, 5957222912ULL, 5611718144ULL, 5050464768ULL, 4294967296ULL, 3374581504ULL, 2324432128ULL, 1184891264ULL,
65 3374581504ULL, 4680582144ULL, 4408998912ULL, 3968072960ULL, 3374581504ULL, 2651326208ULL, 1826357504ULL, 931136000ULL,
66 2324432128ULL, 3224107520ULL, 3036936960ULL, 2733115392ULL, 2324432128ULL, 1826357504ULL, 1258030336ULL, 641204288ULL,
67 1184891264ULL, 1643641088ULL, 1548224000ULL, 1393296000ULL, 1184891264ULL, 931136000ULL, 641204288ULL, 326894240ULL,
68 };
69
70 static const unsigned char RTjpeg_lum_quant_tbl[64] = {
71 16, 11, 10, 16, 24, 40, 51, 61,
72 12, 12, 14, 19, 26, 58, 60, 55,
73 14, 13, 16, 24, 40, 57, 69, 56,
74 14, 17, 22, 29, 51, 87, 80, 62,
75 18, 22, 37, 56, 68, 109, 103, 77,
76 24, 35, 55, 64, 81, 104, 113, 92,
77 49, 64, 78, 87, 103, 121, 120, 101,
78 72, 92, 95, 98, 112, 100, 103, 99
79 };
80
81 static const unsigned char RTjpeg_chrom_quant_tbl[64] = {
82 17, 18, 24, 47, 99, 99, 99, 99,
83 18, 21, 26, 66, 99, 99, 99, 99,
84 24, 26, 56, 99, 99, 99, 99, 99,
85 47, 66, 99, 99, 99, 99, 99, 99,
86 99, 99, 99, 99, 99, 99, 99, 99,
87 99, 99, 99, 99, 99, 99, 99, 99,
88 99, 99, 99, 99, 99, 99, 99, 99,
89 99, 99, 99, 99, 99, 99, 99, 99
90 };
91
92 int RTjpeg_b2s(__s16 *data, __s8 *strm, __u8 bt8)
93 {
94 register int ci, co=1, tmp;
95 register __s16 ZZvalue;
96
97 (__u8)strm[0]=(__u8)(data[RTjpeg_ZZ[0]]>254) ? 254:((data[RTjpeg_ZZ[0]]<0)?0:data[RTjpeg_ZZ[0]]);
98
99 for(ci=1; ci<=bt8; ci++)
100 {
101 ZZvalue = data[RTjpeg_ZZ[ci]];
102
103 if(ZZvalue>0)
104 {
105 strm[co++]=(__s8)(ZZvalue>127)?127:ZZvalue;
106 }
107 else
108 {
109 strm[co++]=(__s8)(ZZvalue<-128)?-128:ZZvalue;
110 }
111 }
112
113 for(; ci<64; ci++)
114 {
115 ZZvalue = data[RTjpeg_ZZ[ci]];
116
117 if(ZZvalue>0)
118 {
119 strm[co++]=(__s8)(ZZvalue>63)?63:ZZvalue;
120 }
121 else if(ZZvalue<0)
122 {
123 strm[co++]=(__s8)(ZZvalue<-64)?-64:ZZvalue;
124 }
125 else /* compress zeros */
126 {
127 tmp=ci;
128 do
129 {
130 ci++;
131 }
132 while((ci<64)&&(data[RTjpeg_ZZ[ci]]==0));
133
134 strm[co++]=(__s8)(63+(ci-tmp));
135 ci--;
136 }
137 }
138 return (int)co;
139 }
140
141 int RTjpeg_s2b(__s16 *data, __s8 *strm, __u8 bt8, __u32 *qtbl)
142 {
143 int ci=1, co=1, tmp;
144 register int i;
145
146 i=RTjpeg_ZZ[0];
147 data[i]=((__u8)strm[0])*qtbl[i];
148
149 for(co=1; co<=bt8; co++)
150 {
151 i=RTjpeg_ZZ[co];
152 data[i]=strm[ci++]*qtbl[i];
153 }
154
155 for(; co<64; co++)
156 {
157 if(strm[ci]>63)
158 {
159 tmp=co+strm[ci]-63;
160 for(; co<tmp; co++)data[RTjpeg_ZZ[co]]=0;
161 co--;
162 } else
163 {
164 i=RTjpeg_ZZ[co];
165 data[i]=strm[ci]*qtbl[i];
166 }
167 ci++;
168 }
169 return (int)ci;
170 }
171
172 #if defined(USE_MMX)
173 void RTjpeg_quant_init(void)
174 {
175 int i;
176 __s16 *qtbl;
177
178 qtbl=(__s16 *)RTjpeg_lqt;
179 for(i=0; i<64; i++)qtbl[i]=(__s16)RTjpeg_lqt[i];
180
181 qtbl=(__s16 *)RTjpeg_cqt;
182 for(i=0; i<64; i++)qtbl[i]=(__s16)RTjpeg_cqt[i];
183 }
184
185 static mmx_t RTjpeg_ones=(mmx_t)(long long)0x0001000100010001LL;
186 static mmx_t RTjpeg_half=(mmx_t)(long long)0x7fff7fff7fff7fffLL;
187
188 void RTjpeg_quant(__s16 *block, __s32 *qtbl)
189 {
190 int i;
191 mmx_t *bl, *ql;
192
193 ql=(mmx_t *)qtbl;
194 bl=(mmx_t *)block;
195
196 movq_m2r(RTjpeg_ones, mm6);
197 movq_m2r(RTjpeg_half, mm7);
198
199 for(i=16; i; i--)
200 {
201 movq_m2r(*(ql++), mm0); /* quant vals (4) */
202 movq_m2r(*bl, mm2); /* block vals (4) */
203 movq_r2r(mm0, mm1);
204 movq_r2r(mm2, mm3);
205
206 punpcklwd_r2r(mm6, mm0); /* 1 qb 1 qa */
207 punpckhwd_r2r(mm6, mm1); /* 1 qd 1 qc */
208
209 punpcklwd_r2r(mm7, mm2); /* 32767 bb 32767 ba */
210 punpckhwd_r2r(mm7, mm3); /* 32767 bd 32767 bc */
211
212 pmaddwd_r2r(mm2, mm0); /* 32767+bb*qb 32767+ba*qa */
213 pmaddwd_r2r(mm3, mm1); /* 32767+bd*qd 32767+bc*qc */
214
215 psrad_i2r(16, mm0);
216 psrad_i2r(16, mm1);
217
218 packssdw_r2r(mm1, mm0);
219
220 movq_r2m(mm0, *(bl++));
221
222 }
223 }
224 #else
225 void RTjpeg_quant_init(void)
226 {
227 }
228
229 void RTjpeg_quant(__s16 *block, __s32 *qtbl)
230 {
231 int i;
232
233 for(i=0; i<64; i++)
234 block[i]=(__s16)((block[i]*qtbl[i]+32767)>>16);
235 }
236 #endif
237
238 /*
239 * Perform the forward DCT on one block of samples.
240 */
241 #ifdef USE_MMX
242 static mmx_t RTjpeg_C4 =(mmx_t)(long long)0x2D412D412D412D41LL;
243 static mmx_t RTjpeg_C6 =(mmx_t)(long long)0x187E187E187E187ELL;
244 static mmx_t RTjpeg_C2mC6=(mmx_t)(long long)0x22A322A322A322A3LL;
245 static mmx_t RTjpeg_C2pC6=(mmx_t)(long long)0x539F539F539F539FLL;
246 static mmx_t RTjpeg_zero =(mmx_t)(long long)0x0000000000000000LL;
247
248 #else
249
250 #define FIX_0_382683433 ((__s32) 98) /* FIX(0.382683433) */
251 #define FIX_0_541196100 ((__s32) 139) /* FIX(0.541196100) */
252 #define FIX_0_707106781 ((__s32) 181) /* FIX(0.707106781) */
253 #define FIX_1_306562965 ((__s32) 334) /* FIX(1.306562965) */
254
255 #define DESCALE10(x) (__s16)( ((x)+128) >> 8)
256 #define DESCALE20(x) (__s16)(((x)+32768) >> 16)
257 #define D_MULTIPLY(var,const) ((__s32) ((var) * (const)))
258 #endif
259
260 void RTjpeg_dct_init(void)
261 {
262 int i;
263
264 for(i=0; i<64; i++)
265 {
266 RTjpeg_lqt[i]=(((__u64)RTjpeg_lqt[i]<<32)/RTjpeg_aan_tab[i]);
267 RTjpeg_cqt[i]=(((__u64)RTjpeg_cqt[i]<<32)/RTjpeg_aan_tab[i]);
268 }
269 }
270
271 void RTjpeg_dctY(__u8 *idata, __s16 *odata, int rskip)
272 {
273 #ifndef MMX
274 __s32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
275 __s32 tmp10, tmp11, tmp12, tmp13;
276 __s32 z1, z2, z3, z4, z5, z11, z13;
277 __u8 *idataptr;
278 __s16 *odataptr;
279 __s32 *wsptr;
280 int ctr;
281
282 idataptr = idata;
283 wsptr = RTjpeg_ws;
284 for (ctr = 7; ctr >= 0; ctr--) {
285 tmp0 = idataptr[0] + idataptr[7];
286 tmp7 = idataptr[0] - idataptr[7];
287 tmp1 = idataptr[1] + idataptr[6];
288 tmp6 = idataptr[1] - idataptr[6];
289 tmp2 = idataptr[2] + idataptr[5];
290 tmp5 = idataptr[2] - idataptr[5];
291 tmp3 = idataptr[3] + idataptr[4];
292 tmp4 = idataptr[3] - idataptr[4];
293
294 tmp10 = (tmp0 + tmp3); /* phase 2 */
295 tmp13 = tmp0 - tmp3;
296 tmp11 = (tmp1 + tmp2);
297 tmp12 = tmp1 - tmp2;
298
299 wsptr[0] = (tmp10 + tmp11)<<8; /* phase 3 */
300 wsptr[4] = (tmp10 - tmp11)<<8;
301
302 z1 = D_MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
303 wsptr[2] = (tmp13<<8) + z1; /* phase 5 */
304 wsptr[6] = (tmp13<<8) - z1;
305
306 tmp10 = tmp4 + tmp5; /* phase 2 */
307 tmp11 = tmp5 + tmp6;
308 tmp12 = tmp6 + tmp7;
309
310 z5 = D_MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
311 z2 = D_MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
312 z4 = D_MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
313 z3 = D_MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
314
315 z11 = (tmp7<<8) + z3; /* phase 5 */
316 z13 = (tmp7<<8) - z3;
317
318 wsptr[5] = z13 + z2; /* phase 6 */
319 wsptr[3] = z13 - z2;
320 wsptr[1] = z11 + z4;
321 wsptr[7] = z11 - z4;
322
323 idataptr += rskip<<3; /* advance pointer to next row */
324 wsptr += 8;
325 }
326
327 wsptr = RTjpeg_ws;
328 odataptr=odata;
329 for (ctr = 7; ctr >= 0; ctr--) {
330 tmp0 = wsptr[0] + wsptr[56];
331 tmp7 = wsptr[0] - wsptr[56];
332 tmp1 = wsptr[8] + wsptr[48];
333 tmp6 = wsptr[8] - wsptr[48];
334 tmp2 = wsptr[16] + wsptr[40];
335 tmp5 = wsptr[16] - wsptr[40];
336 tmp3 = wsptr[24] + wsptr[32];
337 tmp4 = wsptr[24] - wsptr[32];
338
339 tmp10 = tmp0 + tmp3; /* phase 2 */
340 tmp13 = tmp0 - tmp3;
341 tmp11 = tmp1 + tmp2;
342 tmp12 = tmp1 - tmp2;
343
344 odataptr[0] = DESCALE10(tmp10 + tmp11); /* phase 3 */
345 odataptr[32] = DESCALE10(tmp10 - tmp11);
346
347 z1 = D_MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
348 odataptr[16] = DESCALE20((tmp13<<8) + z1); /* phase 5 */
349 odataptr[48] = DESCALE20((tmp13<<8) - z1);
350
351 tmp10 = tmp4 + tmp5; /* phase 2 */
352 tmp11 = tmp5 + tmp6;
353 tmp12 = tmp6 + tmp7;
354
355 z5 = D_MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
356 z2 = D_MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
357 z4 = D_MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
358 z3 = D_MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
359
360 z11 = (tmp7<<8) + z3; /* phase 5 */
361 z13 = (tmp7<<8) - z3;
362
363 odataptr[40] = DESCALE20(z13 + z2); /* phase 6 */
364 odataptr[24] = DESCALE20(z13 - z2);
365 odataptr[8] = DESCALE20(z11 + z4);
366 odataptr[56] = DESCALE20(z11 - z4);
367
368 odataptr++; /* advance pointer to next column */
369 wsptr++;
370 }
371 #else
372 mmx_t tmp6, tmp7;
373 register mmx_t *dataptr = (mmx_t *)odata;
374 mmx_t *idata2 = (mmx_t *)idata;
375
376 /* first copy the input 8 bit to the destination 16 bits */
377
378 movq_m2r(RTjpeg_zero, mm2);
379
380
381 movq_m2r(*idata2, mm0);
382 movq_r2r(mm0, mm1);
383
384 punpcklbw_r2r(mm2, mm0);
385 movq_r2m(mm0, *(dataptr));
386
387 punpckhbw_r2r(mm2, mm1);
388 movq_r2m(mm1, *(dataptr+1));
389
390 idata2 += rskip;
391
392 movq_m2r(*idata2, mm0);
393 movq_r2r(mm0, mm1);
394
395 punpcklbw_r2r(mm2, mm0);
396 movq_r2m(mm0, *(dataptr+2));
397
398 punpckhbw_r2r(mm2, mm1);
399 movq_r2m(mm1, *(dataptr+3));
400
401 idata2 += rskip;
402
403 movq_m2r(*idata2, mm0);
404 movq_r2r(mm0, mm1);
405
406 punpcklbw_r2r(mm2, mm0);
407 movq_r2m(mm0, *(dataptr+4));
408
409 punpckhbw_r2r(mm2, mm1);
410 movq_r2m(mm1, *(dataptr+5));
411
412 idata2 += rskip;
413
414 movq_m2r(*idata2, mm0);
415 movq_r2r(mm0, mm1);
416
417 punpcklbw_r2r(mm2, mm0);
418 movq_r2m(mm0, *(dataptr+6));
419
420 punpckhbw_r2r(mm2, mm1);
421 movq_r2m(mm1, *(dataptr+7));
422
423 idata2 += rskip;
424
425 movq_m2r(*idata2, mm0);
426 movq_r2r(mm0, mm1);
427
428 punpcklbw_r2r(mm2, mm0);
429 movq_r2m(mm0, *(dataptr+8));
430
431 punpckhbw_r2r(mm2, mm1);
432 movq_r2m(mm1, *(dataptr+9));
433
434 idata2 += rskip;
435
436 movq_m2r(*idata2, mm0);
437 movq_r2r(mm0, mm1);
438
439 punpcklbw_r2r(mm2, mm0);
440 movq_r2m(mm0, *(dataptr+10));
441
442 punpckhbw_r2r(mm2, mm1);
443 movq_r2m(mm1, *(dataptr+11));
444
445 idata2 += rskip;
446
447 movq_m2r(*idata2, mm0);
448 movq_r2r(mm0, mm1);
449
450 punpcklbw_r2r(mm2, mm0);
451 movq_r2m(mm0, *(dataptr+12));
452
453 punpckhbw_r2r(mm2, mm1);
454 movq_r2m(mm1, *(dataptr+13));
455
456 idata2 += rskip;
457
458 movq_m2r(*idata2, mm0);
459 movq_r2r(mm0, mm1);
460
461 punpcklbw_r2r(mm2, mm0);
462 movq_r2m(mm0, *(dataptr+14));
463
464 punpckhbw_r2r(mm2, mm1);
465 movq_r2m(mm1, *(dataptr+15));
466
467 /* Start Transpose to do calculations on rows */
468
469 movq_m2r(*(dataptr+9), mm7); /* m03:m02|m01:m00 - first line (line 4)and copy into m5 */
470
471 movq_m2r(*(dataptr+13), mm6); /* m23:m22|m21:m20 - third line (line 6)and copy into m2 */
472 movq_r2r(mm7, mm5);
473
474 punpcklwd_m2r(*(dataptr+11), mm7); /* m11:m01|m10:m00 - interleave first and second lines */
475 movq_r2r(mm6, mm2);
476
477 punpcklwd_m2r(*(dataptr+15), mm6); /* m31:m21|m30:m20 - interleave third and fourth lines */
478 movq_r2r(mm7, mm1);
479
480 movq_m2r(*(dataptr+11), mm3); /* m13:m13|m11:m10 - second line */
481 punpckldq_r2r(mm6, mm7); /* m30:m20|m10:m00 - interleave to produce result 1 */
482
483 movq_m2r(*(dataptr+15), mm0); /* m13:m13|m11:m10 - fourth line */
484 punpckhdq_r2r(mm6, mm1); /* m31:m21|m11:m01 - interleave to produce result 2 */
485
486 movq_r2m(mm7,*(dataptr+9)); /* write result 1 */
487 punpckhwd_r2r(mm3, mm5); /* m13:m03|m12:m02 - interleave first and second lines */
488
489 movq_r2m(mm1,*(dataptr+11)); /* write result 2 */
490 punpckhwd_r2r(mm0, mm2); /* m33:m23|m32:m22 - interleave third and fourth lines */
491
492 movq_r2r(mm5, mm1);
493 punpckldq_r2r(mm2, mm5); /* m32:m22|m12:m02 - interleave to produce result 3 */
494
495 movq_m2r(*(dataptr+1), mm0); /* m03:m02|m01:m00 - first line, 4x4 */
496 punpckhdq_r2r(mm2, mm1); /* m33:m23|m13:m03 - interleave to produce result 4 */
497
498 movq_r2m(mm5,*(dataptr+13)); /* write result 3 */
499
500 /* last 4x4 done */
501
502 movq_r2m(mm1, *(dataptr+15)); /* write result 4, last 4x4 */
503
504 movq_m2r(*(dataptr+5), mm2); /* m23:m22|m21:m20 - third line */
505 movq_r2r(mm0, mm6);
506
507 punpcklwd_m2r(*(dataptr+3), mm0); /* m11:m01|m10:m00 - interleave first and second lines */
508 movq_r2r(mm2, mm7);
509
510 punpcklwd_m2r(*(dataptr+7), mm2); /* m31:m21|m30:m20 - interleave third and fourth lines */
511 movq_r2r(mm0, mm4);
512
513 /* */
514 movq_m2r(*(dataptr+8), mm1); /* n03:n02|n01:n00 - first line */
515 punpckldq_r2r(mm2, mm0); /* m30:m20|m10:m00 - interleave to produce first result */
516
517 movq_m2r(*(dataptr+12), mm3); /* n23:n22|n21:n20 - third line */
518 punpckhdq_r2r(mm2, mm4); /* m31:m21|m11:m01 - interleave to produce second result */
519
520 punpckhwd_m2r(*(dataptr+3), mm6); /* m13:m03|m12:m02 - interleave first and second lines */
521 movq_r2r(mm1, mm2); /* copy first line */
522
523 punpckhwd_m2r(*(dataptr+7), mm7); /* m33:m23|m32:m22 - interleave third and fourth lines */
524 movq_r2r(mm6, mm5); /* copy first intermediate result */
525
526 movq_r2m(mm0, *(dataptr+8)); /* write result 1 */
527 punpckhdq_r2r(mm7, mm5); /* m33:m23|m13:m03 - produce third result */
528
529 punpcklwd_m2r(*(dataptr+10), mm1); /* n11:n01|n10:n00 - interleave first and second lines */
530 movq_r2r(mm3, mm0); /* copy third line */
531
532 punpckhwd_m2r(*(dataptr+10), mm2); /* n13:n03|n12:n02 - interleave first and second lines */
533
534 movq_r2m(mm4, *(dataptr+10)); /* write result 2 out */
535 punpckldq_r2r(mm7, mm6); /* m32:m22|m12:m02 - produce fourth result */
536
537 punpcklwd_m2r(*(dataptr+14), mm3); /* n31:n21|n30:n20 - interleave third and fourth lines */
538 movq_r2r(mm1, mm4);
539
540 movq_r2m(mm6, *(dataptr+12)); /* write result 3 out */
541 punpckldq_r2r(mm3, mm1); /* n30:n20|n10:n00 - produce first result */
542
543 punpckhwd_m2r(*(dataptr+14), mm0); /* n33:n23|n32:n22 - interleave third and fourth lines */
544 movq_r2r(mm2, mm6);
545
546 movq_r2m(mm5, *(dataptr+14)); /* write result 4 out */
547 punpckhdq_r2r(mm3, mm4); /* n31:n21|n11:n01- produce second result */
548
549 movq_r2m(mm1, *(dataptr+1)); /* write result 5 out - (first result for other 4 x 4 block) */
550 punpckldq_r2r(mm0, mm2); /* n32:n22|n12:n02- produce third result */
551
552 movq_r2m(mm4, *(dataptr+3)); /* write result 6 out */
553 punpckhdq_r2r(mm0, mm6); /* n33:n23|n13:n03 - produce fourth result */
554
555 movq_r2m(mm2, *(dataptr+5)); /* write result 7 out */
556
557 movq_m2r(*dataptr, mm0); /* m03:m02|m01:m00 - first line, first 4x4 */
558
559 movq_r2m(mm6, *(dataptr+7)); /* write result 8 out */
560
561
562 /* Do first 4x4 quadrant, which is used in the beginning of the DCT: */
563
564 movq_m2r(*(dataptr+4), mm7); /* m23:m22|m21:m20 - third line */
565 movq_r2r(mm0, mm2);
566
567 punpcklwd_m2r(*(dataptr+2), mm0); /* m11:m01|m10:m00 - interleave first and second lines */
568 movq_r2r(mm7, mm4);
569
570 punpcklwd_m2r(*(dataptr+6), mm7); /* m31:m21|m30:m20 - interleave third and fourth lines */
571 movq_r2r(mm0, mm1);
572
573 movq_m2r(*(dataptr+2), mm6); /* m13:m12|m11:m10 - second line */
574 punpckldq_r2r(mm7, mm0); /* m30:m20|m10:m00 - interleave to produce result 1 */
575
576 movq_m2r(*(dataptr+6), mm5); /* m33:m32|m31:m30 - fourth line */
577 punpckhdq_r2r(mm7, mm1); /* m31:m21|m11:m01 - interleave to produce result 2 */
578
579 movq_r2r(mm0, mm7); /* write result 1 */
580 punpckhwd_r2r(mm6, mm2); /* m13:m03|m12:m02 - interleave first and second lines */
581
582 psubw_m2r(*(dataptr+14), mm7); /* tmp07=x0-x7 /* Stage 1 */ */
583 movq_r2r(mm1, mm6); /* write result 2 */
584
585 paddw_m2r(*(dataptr+14), mm0); /* tmp00=x0+x7 /* Stage 1 */ */
586 punpckhwd_r2r(mm5, mm4); /* m33:m23|m32:m22 - interleave third and fourth lines */
587
588 paddw_m2r(*(dataptr+12), mm1); /* tmp01=x1+x6 /* Stage 1 */ */
589 movq_r2r(mm2, mm3); /* copy first intermediate result */
590
591 psubw_m2r(*(dataptr+12), mm6); /* tmp06=x1-x6 /* Stage 1 */ */
592 punpckldq_r2r(mm4, mm2); /* m32:m22|m12:m02 - interleave to produce result 3 */
593
594 movq_r2m(mm7, tmp7);
595 movq_r2r(mm2, mm5); /* write result 3 */
596
597 movq_r2m(mm6, tmp6);
598 punpckhdq_r2r(mm4, mm3); /* m33:m23|m13:m03 - interleave to produce result 4 */
599
600 paddw_m2r(*(dataptr+10), mm2); /* tmp02=x2+5 /* Stage 1 */ */
601 movq_r2r(mm3, mm4); /* write result 4 */
602
603 /************************************************************************************************
604 End of Transpose
605 ************************************************************************************************/
606
607
608 paddw_m2r(*(dataptr+8), mm3); /* tmp03=x3+x4 /* stage 1*/ */
609 movq_r2r(mm0, mm7);
610
611 psubw_m2r(*(dataptr+8), mm4); /* tmp04=x3-x4 /* stage 1*/ */
612 movq_r2r(mm1, mm6);
613
614 paddw_r2r(mm3, mm0); /* tmp10 = tmp00 + tmp03 /* even 2 */ */
615 psubw_r2r(mm3, mm7); /* tmp13 = tmp00 - tmp03 /* even 2 */ */
616
617 psubw_r2r(mm2, mm6); /* tmp12 = tmp01 - tmp02 /* even 2 */ */
618 paddw_r2r(mm2, mm1); /* tmp11 = tmp01 + tmp02 /* even 2 */ */
619
620 psubw_m2r(*(dataptr+10), mm5); /* tmp05=x2-x5 /* stage 1*/ */
621 paddw_r2r(mm7, mm6); /* tmp12 + tmp13 */
622
623 /* stage 3 */
624
625 movq_m2r(tmp6, mm2);
626 movq_r2r(mm0, mm3);
627
628 psllw_i2r(2, mm6); /* m8 * 2^2 */
629 paddw_r2r(mm1, mm0);
630
631 pmulhw_m2r(RTjpeg_C4, mm6); /* z1 */
632 psubw_r2r(mm1, mm3);
633
634 movq_r2m(mm0, *dataptr);
635 movq_r2r(mm7, mm0);
636
637 /* Odd part */
638 movq_r2m(mm3, *(dataptr+8));
639 paddw_r2r(mm5, mm4); /* tmp10 */
640
641 movq_m2r(tmp7, mm3);
642 paddw_r2r(mm6, mm0); /* tmp32 */
643
644 paddw_r2r(mm2, mm5); /* tmp11 */
645 psubw_r2r(mm6, mm7); /* tmp33 */
646
647 movq_r2m(mm0, *(dataptr+4));
648 paddw_r2r(mm3, mm2); /* tmp12 */
649
650 /* stage 4 */
651
652 movq_r2m(mm7, *(dataptr+12));
653 movq_r2r(mm4, mm1); /* copy of tmp10 */
654
655 psubw_r2r(mm2, mm1); /* tmp10 - tmp12 */
656 psllw_i2r(2, mm4); /* m8 * 2^2 */
657
658 movq_m2r(RTjpeg_C2mC6, mm0);
659 psllw_i2r(2, mm1);
660
661 pmulhw_m2r(RTjpeg_C6, mm1); /* z5 */
662 psllw_i2r(2, mm2);
663
664 pmulhw_r2r(mm0, mm4); /* z5 */
665
666 /* stage 5 */
667
668 pmulhw_m2r(RTjpeg_C2pC6, mm2);
669 psllw_i2r(2, mm5);
670
671 pmulhw_m2r(RTjpeg_C4, mm5); /* z3 */
672 movq_r2r(mm3, mm0); /* copy tmp7 */
673
674 movq_m2r(*(dataptr+1), mm7);
675 paddw_r2r(mm1, mm4); /* z2 */
676
677 paddw_r2r(mm1, mm2); /* z4 */
678
679 paddw_r2r(mm5, mm0); /* z11 */
680 psubw_r2r(mm5, mm3); /* z13 */
681
682 /* stage 6 */
683
684 movq_r2r(mm3, mm5); /* copy z13 */
685 psubw_r2r(mm4, mm3); /* y3=z13 - z2 */
686
687 paddw_r2r(mm4, mm5); /* y5=z13 + z2 */
688 movq_r2r(mm0, mm6); /* copy z11 */
689
690 movq_r2m(mm3, *(dataptr+6)); /*save y3 */
691 psubw_r2r(mm2, mm0); /* y7=z11 - z4 */
692
693 movq_r2m(mm5, *(dataptr+10)); /*save y5 */
694 paddw_r2r(mm2, mm6); /* y1=z11 + z4 */
695
696 movq_r2m(mm0, *(dataptr+14)); /*save y7 */
697
698 /************************************************
699 * End of 1st 4 rows
700 ************************************************/
701
702 movq_m2r(*(dataptr+3), mm1); /* load x1 /* stage 1 */ */
703 movq_r2r(mm7, mm0); /* copy x0 */
704
705 movq_r2m(mm6, *(dataptr+2)); /*save y1 */
706
707 movq_m2r(*(dataptr+5), mm2); /* load x2 /* stage 1 */ */
708 movq_r2r(mm1, mm6); /* copy x1 */
709
710 paddw_m2r(*(dataptr+15), mm0); /* tmp00 = x0 + x7 */
711
712 movq_m2r(*(dataptr+7), mm3); /* load x3 /* stage 1 */ */
713 movq_r2r(mm2, mm5); /* copy x2 */
714
715 psubw_m2r(*(dataptr+15), mm7); /* tmp07 = x0 - x7 */
716 movq_r2r(mm3, mm4); /* copy x3 */
717
718 paddw_m2r(*(dataptr+13), mm1); /* tmp01 = x1 + x6 */
719
720 movq_r2m(mm7, tmp7); /* save tmp07 */
721 movq_r2r(mm0, mm7); /* copy tmp00 */
722
723 psubw_m2r(*(dataptr+13), mm6); /* tmp06 = x1 - x6 */
724
725 /* stage 2, Even Part */
726
727 paddw_m2r(*(dataptr+9), mm3); /* tmp03 = x3 + x4 */
728
729 movq_r2m(mm6, tmp6); /* save tmp07 */
730 movq_r2r(mm1, mm6); /* copy tmp01 */
731
732 paddw_m2r(*(dataptr+11), mm2); /* tmp02 = x2 + x5 */
733 paddw_r2r(mm3, mm0); /* tmp10 = tmp00 + tmp03 */
734
735 psubw_r2r(mm3, mm7); /* tmp13 = tmp00 - tmp03 */
736
737 psubw_m2r(*(dataptr+9), mm4); /* tmp04 = x3 - x4 */
738 psubw_r2r(mm2, mm6); /* tmp12 = tmp01 - tmp02 */
739
740 paddw_r2r(mm2, mm1); /* tmp11 = tmp01 + tmp02 */
741
742 psubw_m2r(*(dataptr+11), mm5); /* tmp05 = x2 - x5 */
743 paddw_r2r(mm7, mm6); /* tmp12 + tmp13 */
744
745 /* stage 3, Even and stage 4 & 5 even */
746
747 movq_m2r(tmp6, mm2); /* load tmp6 */
748 movq_r2r(mm0, mm3); /* copy tmp10 */
749
750 psllw_i2r(2, mm6); /* shift z1 */
751 paddw_r2r(mm1, mm0); /* y0=tmp10 + tmp11 */
752
753 pmulhw_m2r(RTjpeg_C4, mm6); /* z1 */
754 psubw_r2r(mm1, mm3); /* y4=tmp10 - tmp11 */
755
756 movq_r2m(mm0, *(dataptr+1)); /*save y0 */
757 movq_r2r(mm7, mm0); /* copy tmp13 */
758
759 /* odd part */
760
761 movq_r2m(mm3, *(dataptr+9)); /*save y4 */
762 paddw_r2r(mm5, mm4); /* tmp10 = tmp4 + tmp5 */
763
764 movq_m2r(tmp7, mm3); /* load tmp7 */
765 paddw_r2r(mm6, mm0); /* tmp32 = tmp13 + z1 */
766
767 paddw_r2r(mm2, mm5); /* tmp11 = tmp5 + tmp6 */
768 psubw_r2r(mm6, mm7); /* tmp33 = tmp13 - z1 */
769
770 movq_r2m(mm0, *(dataptr+5)); /*save y2 */
771 paddw_r2r(mm3, mm2); /* tmp12 = tmp6 + tmp7 */
772
773 /* stage 4 */
774
775 movq_r2m(mm7, *(dataptr+13)); /*save y6 */
776 movq_r2r(mm4, mm1); /* copy tmp10 */
777
778 psubw_r2r(mm2, mm1); /* tmp10 - tmp12 */
779 psllw_i2r(2, mm4); /* shift tmp10 */
780
781 movq_m2r(RTjpeg_C2mC6, mm0); /* load C2mC6 */
782 psllw_i2r(2, mm1); /* shift (tmp10-tmp12) */
783
784 pmulhw_m2r(RTjpeg_C6, mm1); /* z5 */
785 psllw_i2r(2, mm5); /* prepare for multiply */
786
787 pmulhw_r2r(mm0, mm4); /* multiply by converted real */
788
789 /* stage 5 */
790
791 pmulhw_m2r(RTjpeg_C4, mm5); /* z3 */
792 psllw_i2r(2, mm2); /* prepare for multiply */
793
794 pmulhw_m2r(RTjpeg_C2pC6, mm2); /* multiply */
795 movq_r2r(mm3, mm0); /* copy tmp7 */
796
797 movq_m2r(*(dataptr+9), mm7); /* m03:m02|m01:m00 - first line (line 4)and copy into mm7 */
798 paddw_r2r(mm1, mm4); /* z2 */
799
800 paddw_r2r(mm5, mm0); /* z11 */
801 psubw_r2r(mm5, mm3); /* z13 */
802
803 /* stage 6 */
804
805 movq_r2r(mm3, mm5); /* copy z13 */
806 paddw_r2r(mm1, mm2); /* z4 */
807
808 movq_r2r(mm0, mm6); /* copy z11 */
809 psubw_r2r(mm4, mm5); /* y3 */
810
811 paddw_r2r(mm2, mm6); /* y1 */
812 paddw_r2r(mm4, mm3); /* y5 */
813
814 movq_r2m(mm5, *(dataptr+7)); /*save y3 */
815
816 movq_r2m(mm6, *(dataptr+3)); /*save y1 */
817 psubw_r2r(mm2, mm0); /* y7 */
818
819 /************************************************************************************************
820 Start of Transpose
821 ************************************************************************************************/
822
823 movq_m2r(*(dataptr+13), mm6); /* m23:m22|m21:m20 - third line (line 6)and copy into m2 */
824 movq_r2r(mm7, mm5); /* copy first line */
825
826 punpcklwd_r2r(mm3, mm7); /* m11:m01|m10:m00 - interleave first and second lines */
827 movq_r2r(mm6, mm2); /* copy third line */
828
829 punpcklwd_r2r(mm0, mm6); /* m31:m21|m30:m20 - interleave third and fourth lines */
830 movq_r2r(mm7, mm1); /* copy first intermediate result */
831
832 punpckldq_r2r(mm6, mm7); /* m30:m20|m10:m00 - interleave to produce result 1 */
833
834 punpckhdq_r2r(mm6, mm1); /* m31:m21|m11:m01 - interleave to produce result 2 */
835
836 movq_r2m(mm7, *(dataptr+9)); /* write result 1 */
837 punpckhwd_r2r(mm3, mm5); /* m13:m03|m12:m02 - interleave first and second lines */
838
839 movq_r2m(mm1, *(dataptr+11)); /* write result 2 */
840 punpckhwd_r2r(mm0, mm2); /* m33:m23|m32:m22 - interleave third and fourth lines */
841
842 movq_r2r(mm5, mm1); /* copy first intermediate result */
843 punpckldq_r2r(mm2, mm5); /* m32:m22|m12:m02 - interleave to produce result 3 */
844
845 movq_m2r(*(dataptr+1), mm0); /* m03:m02|m01:m00 - first line, 4x4 */
846 punpckhdq_r2r(mm2, mm1); /* m33:m23|m13:m03 - interleave to produce result 4 */
847
848 movq_r2m(mm5, *(dataptr+13)); /* write result 3 */
849
850 /****** last 4x4 done */
851
852 movq_r2m(mm1, *(dataptr+15)); /* write result 4, last 4x4 */
853
854 movq_m2r(*(dataptr+5), mm2); /* m23:m22|m21:m20 - third line */
855 movq_r2r(mm0, mm6); /* copy first line */
856
857 punpcklwd_m2r(*(dataptr+3), mm0); /* m11:m01|m10:m00 - interleave first and second lines */
858 movq_r2r(mm2, mm7); /* copy third line */
859
860 punpcklwd_m2r(*(dataptr+7), mm2); /* m31:m21|m30:m20 - interleave third and fourth lines */
861 movq_r2r(mm0, mm4); /* copy first intermediate result */
862
863
864
865 movq_m2r(*(dataptr+8), mm1); /* n03:n02|n01:n00 - first line */
866 punpckldq_r2r(mm2, mm0); /* m30:m20|m10:m00 - interleave to produce first result */
867
868 movq_m2r(*(dataptr+12), mm3); /* n23:n22|n21:n20 - third line */
869 punpckhdq_r2r(mm2, mm4); /* m31:m21|m11:m01 - interleave to produce second result */
870
871 punpckhwd_m2r(*(dataptr+3), mm6); /* m13:m03|m12:m02 - interleave first and second lines */
872 movq_r2r(mm1, mm2); /* copy first line */
873
874 punpckhwd_m2r(*(dataptr+7), mm7); /* m33:m23|m32:m22 - interleave third and fourth lines */
875 movq_r2r(mm6, mm5); /* copy first intermediate result */
876
877 movq_r2m(mm0, *(dataptr+8)); /* write result 1 */
878 punpckhdq_r2r(mm7, mm5); /* m33:m23|m13:m03 - produce third result */
879
880 punpcklwd_m2r(*(dataptr+10), mm1); /* n11:n01|n10:n00 - interleave first and second lines */
881 movq_r2r(mm3, mm0); /* copy third line */
882
883 punpckhwd_m2r(*(dataptr+10), mm2); /* n13:n03|n12:n02 - interleave first and second lines */
884
885 movq_r2m(mm4, *(dataptr+10)); /* write result 2 out */
886 punpckldq_r2r(mm7, mm6); /* m32:m22|m12:m02 - produce fourth result */
887
888 punpcklwd_m2r(*(dataptr+14), mm3); /* n33:n23|n32:n22 - interleave third and fourth lines */
889 movq_r2r(mm1, mm4); /* copy second intermediate result */
890
891 movq_r2m(mm6, *(dataptr+12)); /* write result 3 out */
892 punpckldq_r2r(mm3, mm1); /* */
893
894 punpckhwd_m2r(*(dataptr+14), mm0); /* n33:n23|n32:n22 - interleave third and fourth lines */
895 movq_r2r(mm2, mm6); /* copy second intermediate result */
896
897 movq_r2m(mm5, *(dataptr+14)); /* write result 4 out */
898 punpckhdq_r2r(mm3, mm4); /* n31:n21|n11:n01- produce second result */
899
900 movq_r2m(mm1, *(dataptr+1)); /* write result 5 out - (first result for other 4 x 4 block) */
901 punpckldq_r2r(mm0, mm2); /* n32:n22|n12:n02- produce third result */
902
903 movq_r2m(mm4, *(dataptr+3)); /* write result 6 out */
904 punpckhdq_r2r(mm0, mm6); /* n33:n23|n13:n03 - produce fourth result */
905
906 movq_r2m(mm2, *(dataptr+5)); /* write result 7 out */
907
908 movq_m2r(*dataptr, mm0); /* m03:m02|m01:m00 - first line, first 4x4 */
909
910 movq_r2m(mm6, *(dataptr+7)); /* write result 8 out */
911
912 /* Do first 4x4 quadrant, which is used in the beginning of the DCT: */
913
914 movq_m2r(*(dataptr+4), mm7); /* m23:m22|m21:m20 - third line */
915 movq_r2r(mm0, mm2); /* copy first line */
916
917 punpcklwd_m2r(*(dataptr+2), mm0); /* m11:m01|m10:m00 - interleave first and second lines */
918 movq_r2r(mm7, mm4); /* copy third line */
919
920 punpcklwd_m2r(*(dataptr+6), mm7); /* m31:m21|m30:m20 - interleave third and fourth lines */
921 movq_r2r(mm0, mm1); /* copy first intermediate result */
922
923 movq_m2r(*(dataptr+2), mm6); /* m13:m12|m11:m10 - second line */
924 punpckldq_r2r(mm7, mm0); /* m30:m20|m10:m00 - interleave to produce result 1 */
925
926 movq_m2r(*(dataptr+6), mm5); /* m33:m32|m31:m30 - fourth line */
927 punpckhdq_r2r(mm7, mm1); /* m31:m21|m11:m01 - interleave to produce result 2 */
928
929 movq_r2r(mm0, mm7); /* write result 1 */
930 punpckhwd_r2r(mm6, mm2); /* m13:m03|m12:m02 - interleave first and second lines */
931
932 psubw_m2r(*(dataptr+14), mm7); /* tmp07=x0-x7 /* Stage 1 */ */
933 movq_r2r(mm1, mm6); /* write result 2 */
934
935 paddw_m2r(*(dataptr+14), mm0); /* tmp00=x0+x7 /* Stage 1 */ */
936 punpckhwd_r2r(mm5, mm4); /* m33:m23|m32:m22 - interleave third and fourth lines */
937
938 paddw_m2r(*(dataptr+12), mm1); /* tmp01=x1+x6 /* Stage 1 */ */
939 movq_r2r(mm2, mm3); /* copy first intermediate result */
940
941 psubw_m2r(*(dataptr+12), mm6); /* tmp06=x1-x6 /* Stage 1 */ */
942 punpckldq_r2r(mm4, mm2); /* m32:m22|m12:m02 - interleave to produce result 3 */
943
944 movq_r2m(mm7, tmp7); /* save tmp07 */
945 movq_r2r(mm2, mm5); /* write result 3 */
946
947 movq_r2m(mm6, tmp6); /* save tmp06 */
948
949 punpckhdq_r2r(mm4, mm3); /* m33:m23|m13:m03 - interleave to produce result 4 */
950
951 paddw_m2r(*(dataptr+10), mm2); /* tmp02=x2+x5 /* stage 1 */ */
952 movq_r2r(mm3, mm4); /* write result 4 */
953
954 /************************************************************************************************
955 End of Transpose 2
956 ************************************************************************************************/
957
958 paddw_m2r(*(dataptr+8), mm3); /* tmp03=x3+x4 /* stage 1*/ */
959 movq_r2r(mm0, mm7);
960
961 psubw_m2r(*(dataptr+8), mm4); /* tmp04=x3-x4 /* stage 1*/ */
962 movq_r2r(mm1, mm6);
963
964 paddw_r2r(mm3, mm0); /* tmp10 = tmp00 + tmp03 /* even 2 */ */
965 psubw_r2r(mm3, mm7); /* tmp13 = tmp00 - tmp03 /* even 2 */ */
966
967 psubw_r2r(mm2, mm6); /* tmp12 = tmp01 - tmp02 /* even 2 */ */
968 paddw_r2r(mm2, mm1); /* tmp11 = tmp01 + tmp02 /* even 2 */ */
969
970 psubw_m2r(*(dataptr+10), mm5); /* tmp05=x2-x5 /* stage 1*/ */
971 paddw_r2r(mm7, mm6); /* tmp12 + tmp13 */
972
973 /* stage 3 */
974
975 movq_m2r(tmp6, mm2);
976 movq_r2r(mm0, mm3);
977
978 psllw_i2r(2, mm6); /* m8 * 2^2 */
979 paddw_r2r(mm1, mm0);
980
981 pmulhw_m2r(RTjpeg_C4, mm6); /* z1 */
982 psubw_r2r(mm1, mm3);
983
984 movq_r2m(mm0, *dataptr);
985 movq_r2r(mm7, mm0);
986
987 /* Odd part */
988 movq_r2m(mm3, *(dataptr+8));
989 paddw_r2r(mm5, mm4); /* tmp10 */
990
991 movq_m2r(tmp7, mm3);
992 paddw_r2r(mm6, mm0); /* tmp32 */
993
994 paddw_r2r(mm2, mm5); /* tmp11 */
995 psubw_r2r(mm6, mm7); /* tmp33 */
996
997 movq_r2m(mm0, *(dataptr+4));
998 paddw_r2r(mm3, mm2); /* tmp12 */
999
1000 /* stage 4 */
1001 movq_r2m(mm7, *(dataptr+12));
1002 movq_r2r(mm4, mm1); /* copy of tmp10 */
1003
1004 psubw_r2r(mm2, mm1); /* tmp10 - tmp12 */
1005 psllw_i2r(2, mm4); /* m8 * 2^2 */
1006
1007 movq_m2r(RTjpeg_C2mC6, mm0);
1008 psllw_i2r(2, mm1);
1009
1010 pmulhw_m2r(RTjpeg_C6, mm1); /* z5 */
1011 psllw_i2r(2, mm2);
1012
1013 pmulhw_r2r(mm0, mm4); /* z5 */
1014
1015 /* stage 5 */
1016
1017 pmulhw_m2r(RTjpeg_C2pC6, mm2);
1018 psllw_i2r(2, mm5);
1019
1020 pmulhw_m2r(RTjpeg_C4, mm5); /* z3 */
1021 movq_r2r(mm3, mm0); /* copy tmp7 */
1022
1023 movq_m2r(*(dataptr+1), mm7);
1024 paddw_r2r(mm1, mm4); /* z2 */
1025
1026 paddw_r2r(mm1, mm2); /* z4 */
1027
1028 paddw_r2r(mm5, mm0); /* z11 */
1029 psubw_r2r(mm5, mm3); /* z13 */
1030
1031 /* stage 6 */
1032
1033 movq_r2r(mm3, mm5); /* copy z13 */
1034 psubw_r2r(mm4, mm3); /* y3=z13 - z2 */
1035
1036 paddw_r2r(mm4, mm5); /* y5=z13 + z2 */
1037 movq_r2r(mm0, mm6); /* copy z11 */
1038
1039 movq_r2m(mm3, *(dataptr+6)); /*save y3 */
1040 psubw_r2r(mm2, mm0); /* y7=z11 - z4 */
1041
1042 movq_r2m(mm5, *(dataptr+10)); /*save y5 */
1043 paddw_r2r(mm2, mm6); /* y1=z11 + z4 */
1044
1045 movq_r2m(mm0, *(dataptr+14)); /*save y7 */
1046
1047 /************************************************
1048 * End of 1st 4 rows
1049 ************************************************/
1050
1051 movq_m2r(*(dataptr+3), mm1); /* load x1 /* stage 1 */ */
1052 movq_r2r(mm7, mm0); /* copy x0 */
1053
1054 movq_r2m(mm6, *(dataptr+2)); /*save y1 */
1055
1056 movq_m2r(*(dataptr+5), mm2); /* load x2 /* stage 1 */ */
1057 movq_r2r(mm1, mm6); /* copy x1 */
1058
1059 paddw_m2r(*(dataptr+15), mm0); /* tmp00 = x0 + x7 */
1060
1061 movq_m2r(*(dataptr+7), mm3); /* load x3 /* stage 1 */ */
1062 movq_r2r(mm2, mm5); /* copy x2 */
1063
1064 psubw_m2r(*(dataptr+15), mm7); /* tmp07 = x0 - x7 */
1065 movq_r2r(mm3, mm4); /* copy x3 */
1066
1067 paddw_m2r(*(dataptr+13), mm1); /* tmp01 = x1 + x6 */
1068
1069 movq_r2m(mm7, tmp7); /* save tmp07 */
1070 movq_r2r(mm0, mm7); /* copy tmp00 */
1071
1072 psubw_m2r(*(dataptr+13), mm6); /* tmp06 = x1 - x6 */
1073
1074 /* stage 2, Even Part */
1075
1076 paddw_m2r(*(dataptr+9), mm3); /* tmp03 = x3 + x4 */
1077
1078 movq_r2m(mm6, tmp6); /* save tmp07 */
1079 movq_r2r(mm1, mm6); /* copy tmp01 */
1080
1081 paddw_m2r(*(dataptr+11), mm2); /* tmp02 = x2 + x5 */
1082 paddw_r2r(mm3, mm0); /* tmp10 = tmp00 + tmp03 */
1083
1084 psubw_r2r(mm3, mm7); /* tmp13 = tmp00 - tmp03 */
1085
1086 psubw_m2r(*(dataptr+9), mm4); /* tmp04 = x3 - x4 */
1087 psubw_r2r(mm2, mm6); /* tmp12 = tmp01 - tmp02 */
1088
1089 paddw_r2r(mm2, mm1); /* tmp11 = tmp01 + tmp02 */
1090
1091 psubw_m2r(*(dataptr+11), mm5); /* tmp05 = x2 - x5 */
1092 paddw_r2r(mm7, mm6); /* tmp12 + tmp13 */
1093
1094 /* stage 3, Even and stage 4 & 5 even */
1095
1096 movq_m2r(tmp6, mm2); /* load tmp6 */
1097 movq_r2r(mm0, mm3); /* copy tmp10 */
1098
1099 psllw_i2r(2, mm6); /* shift z1 */
1100 paddw_r2r(mm1, mm0); /* y0=tmp10 + tmp11 */
1101
1102 pmulhw_m2r(RTjpeg_C4, mm6); /* z1 */
1103 psubw_r2r(mm1, mm3); /* y4=tmp10 - tmp11 */
1104
1105 movq_r2m(mm0, *(dataptr+1)); /*save y0 */
1106 movq_r2r(mm7, mm0); /* copy tmp13 */
1107
1108 /* odd part */
1109
1110 movq_r2m(mm3, *(dataptr+9)); /*save y4 */
1111 paddw_r2r(mm5, mm4); /* tmp10 = tmp4 + tmp5 */
1112
1113 movq_m2r(tmp7, mm3); /* load tmp7 */
1114 paddw_r2r(mm6, mm0); /* tmp32 = tmp13 + z1 */
1115
1116 paddw_r2r(mm2, mm5); /* tmp11 = tmp5 + tmp6 */
1117 psubw_r2r(mm6, mm7); /* tmp33 = tmp13 - z1 */
1118
1119 movq_r2m(mm0, *(dataptr+5)); /*save y2 */
1120 paddw_r2r(mm3, mm2); /* tmp12 = tmp6 + tmp7 */
1121
1122 /* stage 4 */
1123
1124 movq_r2m(mm7, *(dataptr+13)); /*save y6 */
1125 movq_r2r(mm4, mm1); /* copy tmp10 */
1126
1127 psubw_r2r(mm2, mm1); /* tmp10 - tmp12 */
1128 psllw_i2r(2, mm4); /* shift tmp10 */
1129
1130 movq_m2r(RTjpeg_C2mC6, mm0); /* load C2mC6 */
1131 psllw_i2r(2, mm1); /* shift (tmp10-tmp12) */
1132
1133 pmulhw_m2r(RTjpeg_C6, mm1); /* z5 */
1134 psllw_i2r(2, mm5); /* prepare for multiply */
1135
1136 pmulhw_r2r(mm0, mm4); /* multiply by converted real */
1137
1138 /* stage 5 */
1139
1140 pmulhw_m2r(RTjpeg_C4, mm5); /* z3 */
1141 psllw_i2r(2, mm2); /* prepare for multiply */
1142
1143 pmulhw_m2r(RTjpeg_C2pC6, mm2); /* multiply */
1144 movq_r2r(mm3, mm0); /* copy tmp7 */
1145
1146 movq_m2r(*(dataptr+9), mm7); /* m03:m02|m01:m00 - first line (line 4)and copy into mm7 */
1147 paddw_r2r(mm1, mm4); /* z2 */
1148
1149 paddw_r2r(mm5, mm0); /* z11 */
1150 psubw_r2r(mm5, mm3); /* z13 */
1151
1152 /* stage 6 */
1153
1154 movq_r2r(mm3, mm5); /* copy z13 */
1155 paddw_r2r(mm1, mm2); /* z4 */
1156
1157 movq_r2r(mm0, mm6); /* copy z11 */
1158 psubw_r2r(mm4, mm5); /* y3 */
1159
1160 paddw_r2r(mm2, mm6); /* y1 */
1161 paddw_r2r(mm4, mm3); /* y5 */
1162
1163 movq_r2m(mm5, *(dataptr+7)); /*save y3 */
1164 psubw_r2r(mm2, mm0); /* yè=z11 - z4 */
1165
1166 movq_r2m(mm3, *(dataptr+11)); /*save y5 */
1167
1168 movq_r2m(mm6, *(dataptr+3)); /*save y1 */
1169
1170 movq_r2m(mm0, *(dataptr+15)); /*save y7 */
1171
1172
1173 #endif
1174 }
1175
1176 #define FIX_1_082392200 ((__s32) 277) /* FIX(1.082392200) */
1177 #define FIX_1_414213562 ((__s32) 362) /* FIX(1.414213562) */
1178 #define FIX_1_847759065 ((__s32) 473) /* FIX(1.847759065) */
1179 #define FIX_2_613125930 ((__s32) 669) /* FIX(2.613125930) */
1180
1181 #define DESCALE(x) (__s16)( ((x)+4) >> 3)
1182
1183 /* clip yuv to 16..235 (should be 16..240 for cr/cb but ... */
1184
1185 #define RL(x) ((x)>235) ? 235 : (((x)<16) ? 16 : (x))
1186 #define MULTIPLY(var,const) (((__s32) ((var) * (const)) + 128)>>8)
1187
1188 void RTjpeg_idct_init(void)
1189 {
1190 int i;
1191
1192 for(i=0; i<64; i++)
1193 {
1194 RTjpeg_liqt[i]=((__u64)RTjpeg_liqt[i]*RTjpeg_aan_tab[i])>>32;
1195 RTjpeg_ciqt[i]=((__u64)RTjpeg_ciqt[i]*RTjpeg_aan_tab[i])>>32;
1196 }
1197 }
1198
1199 void RTjpeg_idct(__u8 *odata, __s16 *data, int rskip)
1200 {
1201 #ifdef USE_MMX
1202
1203 static mmx_t fix_141 = (mmx_t)(long long)0x5a825a825a825a82LL;
1204 static mmx_t fix_184n261 = (mmx_t)(long long)0xcf04cf04cf04cf04LL;
1205 static mmx_t fix_184 = (mmx_t)(long long)0x7641764176417641LL;
1206 static mmx_t fix_n184 = (mmx_t)(long long)0x896f896f896f896fLL;
1207 static mmx_t fix_108n184 = (mmx_t)(long long)0xcf04cf04cf04cf04LL;
1208
1209 mmx_t workspace[64];
1210 mmx_t *wsptr = workspace;
1211 register mmx_t *dataptr = (mmx_t *)odata;
1212 mmx_t *idata = (mmx_t *)data;
1213
1214 rskip = rskip>>3;
1215 /*
1216 * Perform inverse DCT on one block of coefficients.
1217 */
1218
1219 /* Odd part */
1220
1221 movq_m2r(*(idata+10), mm1); /* load idata[DCTSIZE*5] */
1222
1223 movq_m2r(*(idata+6), mm0); /* load idata[DCTSIZE*3] */
1224
1225 movq_m2r(*(idata+2), mm3); /* load idata[DCTSIZE*1] */
1226
1227 movq_r2r(mm1, mm2); /* copy tmp6 /* phase 6 */ */
1228
1229 movq_m2r(*(idata+14), mm4); /* load idata[DCTSIZE*7] */
1230
1231 paddw_r2r(mm0, mm1); /* z13 = tmp6 + tmp5; */
1232
1233 psubw_r2r(mm0, mm2); /* z10 = tmp6 - tmp5 */
1234
1235 psllw_i2r(2, mm2); /* shift z10 */
1236 movq_r2r(mm2, mm0); /* copy z10 */
1237
1238 pmulhw_m2r(fix_184n261, mm2); /* MULTIPLY( z12, FIX_1_847759065); /* 2*c2 */ */
1239 movq_r2r(mm3, mm5); /* copy tmp4 */
1240
1241 pmulhw_m2r(fix_n184, mm0); /* MULTIPLY(z10, -FIX_1_847759065); /* 2*c2 */ */
1242 paddw_r2r(mm4, mm3); /* z11 = tmp4 + tmp7; */
1243
1244 movq_r2r(mm3, mm6); /* copy z11 /* phase 5 */ */
1245 psubw_r2r(mm4, mm5); /* z12 = tmp4 - tmp7; */
1246
1247 psubw_r2r(mm1, mm6); /* z11-z13 */
1248 psllw_i2r(2, mm5); /* shift z12 */
1249
1250 movq_m2r(*(idata+12), mm4); /* load idata[DCTSIZE*6], even part */
1251 movq_r2r(mm5, mm7); /* copy z12 */
1252
1253 pmulhw_m2r(fix_108n184, mm5); /* MULT(z12, (FIX_1_08-FIX_1_84)) //- z5; /* 2*(c2-c6) */ even part */
1254 paddw_r2r(mm1, mm3); /* tmp7 = z11 + z13; */
1255
1256 /*ok */
1257
1258 /* Even part */
1259 pmulhw_m2r(fix_184, mm7); /* MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) //+ z5; /* -2*(c2+c6) */ */
1260 psllw_i2r(2, mm6);
1261
1262 movq_m2r(*(idata+4), mm1); /* load idata[DCTSIZE*2] */
1263
1264 paddw_r2r(mm5, mm0); /* tmp10 */
1265
1266 paddw_r2r(mm7, mm2); /* tmp12 */
1267
1268 pmulhw_m2r(fix_141, mm6); /* tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */ */
1269 psubw_r2r(mm3, mm2); /* tmp6 = tmp12 - tmp7 */
1270
1271 movq_r2r(mm1, mm5); /* copy tmp1 */
1272 paddw_r2r(mm4, mm1); /* tmp13= tmp1 + tmp3; /* phases 5-3 */ */
1273
1274 psubw_r2r(mm4, mm5); /* tmp1-tmp3 */
1275 psubw_r2r(mm2, mm6); /* tmp5 = tmp11 - tmp6; */
1276
1277 movq_r2m(mm1, *(wsptr)); /* save tmp13 in workspace */
1278 psllw_i2r(2, mm5); /* shift tmp1-tmp3 */
1279
1280 movq_m2r(*(idata), mm7); /* load idata[DCTSIZE*0] */
1281
1282 pmulhw_m2r(fix_141, mm5); /* MULTIPLY(tmp1 - tmp3, FIX_1_414213562) */
1283 paddw_r2r(mm6, mm0); /* tmp4 = tmp10 + tmp5; */
1284
1285 movq_m2r(*(idata+8), mm4); /* load idata[DCTSIZE*4] */
1286
1287 psubw_r2r(mm1, mm5); /* tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */ */
1288
1289 movq_r2m(mm0, *(wsptr+4)); /* save tmp4 in workspace */
1290 movq_r2r(mm7, mm1); /* copy tmp0 /* phase 3 */ */
1291
1292 movq_r2m(mm5, *(wsptr+2)); /* save tmp12 in workspace */
1293 psubw_r2r(mm4, mm1); /* tmp11 = tmp0 - tmp2; */
1294
1295 paddw_r2r(mm4, mm7); /* tmp10 = tmp0 + tmp2; */
1296 movq_r2r(mm1, mm5); /* copy tmp11 */
1297
1298 paddw_m2r(*(wsptr+2), mm1); /* tmp1 = tmp11 + tmp12; */
1299 movq_r2r(mm7, mm4); /* copy tmp10 /* phase 2 */ */
1300
1301 paddw_m2r(*(wsptr), mm7); /* tmp0 = tmp10 + tmp13; */
1302
1303 psubw_m2r(*(wsptr), mm4); /* tmp3 = tmp10 - tmp13; */
1304 movq_r2r(mm7, mm0); /* copy tmp0 */
1305
1306 psubw_m2r(*(wsptr+2), mm5); /* tmp2 = tmp11 - tmp12; */
1307 paddw_r2r(mm3, mm7); /* wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7); */
1308
1309 psubw_r2r(mm3, mm0); /* wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7); */
1310
1311 movq_r2m(mm7, *(wsptr)); /* wsptr[DCTSIZE*0] */
1312 movq_r2r(mm1, mm3); /* copy tmp1 */
1313
1314 movq_r2m(mm0, *(wsptr+14)); /* wsptr[DCTSIZE*7] */
1315 paddw_r2r(mm2, mm1); /* wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6); */
1316
1317 psubw_r2r(mm2, mm3); /* wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6); */
1318
1319 movq_r2m(mm1, *(wsptr+2)); /* wsptr[DCTSIZE*1] */
1320 movq_r2r(mm4, mm1); /* copy tmp3 */
1321
1322 movq_r2m(mm3, *(wsptr+12)); /* wsptr[DCTSIZE*6] */
1323
1324 paddw_m2r(*(wsptr+4), mm4); /* wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4); */
1325
1326 psubw_m2r(*(wsptr+4), mm1); /* wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4); */
1327
1328 movq_r2m(mm4, *(wsptr+8));
1329 movq_r2r(mm5, mm7); /* copy tmp2 */
1330
1331 paddw_r2r(mm6, mm5); /* wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5) */
1332
1333 movq_r2m(mm1, *(wsptr+6));
1334 psubw_r2r(mm6, mm7); /* wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5); */
1335
1336 movq_r2m(mm5, *(wsptr+4));
1337
1338 movq_r2m(mm7, *(wsptr+10));
1339
1340 /*ok */
1341
1342
1343 /*****************************************************************/
1344
1345 idata++;
1346 wsptr++;
1347
1348 /*****************************************************************/
1349
1350 movq_m2r(*(idata+10), mm1); /* load idata[DCTSIZE*5] */
1351
1352 movq_m2r(*(idata+6), mm0); /* load idata[DCTSIZE*3] */
1353
1354 movq_m2r(*(idata+2), mm3); /* load idata[DCTSIZE*1] */
1355 movq_r2r(mm1, mm2); /* copy tmp6 /* phase 6 */ */
1356
1357 movq_m2r(*(idata+14), mm4); /* load idata[DCTSIZE*7] */
1358 paddw_r2r(mm0, mm1); /* z13 = tmp6 + tmp5; */
1359
1360 psubw_r2r(mm0, mm2); /* z10 = tmp6 - tmp5 */
1361
1362 psllw_i2r(2, mm2); /* shift z10 */
1363 movq_r2r(mm2, mm0); /* copy z10 */
1364
1365 pmulhw_m2r(fix_184n261, mm2); /* MULTIPLY( z12, FIX_1_847759065); /* 2*c2 */ */
1366 movq_r2r(mm3, mm5); /* copy tmp4 */
1367
1368 pmulhw_m2r(fix_n184, mm0); /* MULTIPLY(z10, -FIX_1_847759065); /* 2*c2 */ */
1369 paddw_r2r(mm4, mm3); /* z11 = tmp4 + tmp7; */
1370
1371 movq_r2r(mm3, mm6); /* copy z11 /* phase 5 */ */
1372 psubw_r2r(mm4, mm5); /* z12 = tmp4 - tmp7; */
1373
1374 psubw_r2r(mm1, mm6); /* z11-z13 */
1375 psllw_i2r(2, mm5); /* shift z12 */
1376
1377 movq_m2r(*(idata+12), mm4); /* load idata[DCTSIZE*6], even part */
1378 movq_r2r(mm5, mm7); /* copy z12 */
1379
1380 pmulhw_m2r(fix_108n184, mm5); /* MULT(z12, (FIX_1_08-FIX_1_84)) //- z5; /* 2*(c2-c6) */ even part */
1381 paddw_r2r(mm1, mm3); /* tmp7 = z11 + z13; */
1382
1383 /*ok */
1384
1385 /* Even part */
1386 pmulhw_m2r(fix_184, mm7); /* MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) //+ z5; /* -2*(c2+c6) */ */
1387 psllw_i2r(2, mm6);
1388
1389 movq_m2r(*(idata+4), mm1); /* load idata[DCTSIZE*2] */
1390
1391 paddw_r2r(mm5, mm0); /* tmp10 */
1392
1393 paddw_r2r(mm7, mm2); /* tmp12 */
1394
1395 pmulhw_m2r(fix_141, mm6); /* tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */ */
1396 psubw_r2r(mm3, mm2); /* tmp6 = tmp12 - tmp7 */
1397
1398 movq_r2r(mm1, mm5); /* copy tmp1 */
1399 paddw_r2r(mm4, mm1); /* tmp13= tmp1 + tmp3; /* phases 5-3 */ */
1400
1401 psubw_r2r(mm4, mm5); /* tmp1-tmp3 */
1402 psubw_r2r(mm2, mm6); /* tmp5 = tmp11 - tmp6; */
1403
1404 movq_r2m(mm1, *(wsptr)); /* save tmp13 in workspace */
1405 psllw_i2r(2, mm5); /* shift tmp1-tmp3 */
1406
1407 movq_m2r(*(idata), mm7); /* load idata[DCTSIZE*0] */
1408 paddw_r2r(mm6, mm0); /* tmp4 = tmp10 + tmp5; */
1409
1410 pmulhw_m2r(fix_141, mm5); /* MULTIPLY(tmp1 - tmp3, FIX_1_414213562) */
1411
1412 movq_m2r(*(idata+8), mm4); /* load idata[DCTSIZE*4] */
1413
1414 psubw_r2r(mm1, mm5); /* tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */ */
1415
1416 movq_r2m(mm0, *(wsptr+4)); /* save tmp4 in workspace */
1417 movq_r2r(mm7, mm1); /* copy tmp0 /* phase 3 */ */
1418
1419 movq_r2m(mm5, *(wsptr+2)); /* save tmp12 in workspace */
1420 psubw_r2r(mm4, mm1); /* tmp11 = tmp0 - tmp2; */
1421
1422 paddw_r2r(mm4, mm7); /* tmp10 = tmp0 + tmp2; */
1423 movq_r2r(mm1, mm5); /* copy tmp11 */
1424
1425 paddw_m2r(*(wsptr+2), mm1); /* tmp1 = tmp11 + tmp12; */
1426 movq_r2r(mm7, mm4); /* copy tmp10 /* phase 2 */ */
1427
1428 paddw_m2r(*(wsptr), mm7); /* tmp0 = tmp10 + tmp13; */
1429
1430 psubw_m2r(*(wsptr), mm4); /* tmp3 = tmp10 - tmp13; */
1431 movq_r2r(mm7, mm0); /* copy tmp0 */
1432
1433 psubw_m2r(*(wsptr+2), mm5); /* tmp2 = tmp11 - tmp12; */
1434 paddw_r2r(mm3, mm7); /* wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7); */
1435
1436 psubw_r2r(mm3, mm0); /* wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7); */
1437
1438 movq_r2m(mm7, *(wsptr)); /* wsptr[DCTSIZE*0] */
1439 movq_r2r(mm1, mm3); /* copy tmp1 */
1440
1441 movq_r2m(mm0, *(wsptr+14)); /* wsptr[DCTSIZE*7] */
1442 paddw_r2r(mm2, mm1); /* wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6); */
1443
1444 psubw_r2r(mm2, mm3); /* wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6); */
1445
1446 movq_r2m(mm1, *(wsptr+2)); /* wsptr[DCTSIZE*1] */
1447 movq_r2r(mm4, mm1); /* copy tmp3 */
1448
1449 movq_r2m(mm3, *(wsptr+12)); /* wsptr[DCTSIZE*6] */
1450
1451 paddw_m2r(*(wsptr+4), mm4); /* wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4); */
1452
1453 psubw_m2r(*(wsptr+4), mm1); /* wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4); */
1454
1455 movq_r2m(mm4, *(wsptr+8));
1456 movq_r2r(mm5, mm7); /* copy tmp2 */
1457
1458 paddw_r2r(mm6, mm5); /* wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5) */
1459
1460 movq_r2m(mm1, *(wsptr+6));
1461 psubw_r2r(mm6, mm7); /* wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5); */
1462
1463 movq_r2m(mm5, *(wsptr+4));
1464
1465 movq_r2m(mm7, *(wsptr+10));
1466
1467 /*****************************************************************/
1468
1469 /* Pass 2: process rows from work array, store into output array. */
1470 /* Note that we must descale the results by a factor of 8 == 2**3, */
1471 /* and also undo the PASS1_BITS scaling. */
1472
1473 /*****************************************************************/
1474 /* Even part */
1475
1476 wsptr--;
1477
1478 /* tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]); */
1479 /* tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]); */
1480 /* tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]); */
1481 /* tmp14 = ((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6]); */
1482 movq_m2r(*(wsptr), mm0); /* wsptr[0,0],[0,1],[0,2],[0,3] */
1483
1484 movq_m2r(*(wsptr+1), mm1); /* wsptr[0,4],[0,5],[0,6],[0,7] */
1485 movq_r2r(mm0, mm2);
1486
1487 movq_m2r(*(wsptr+2), mm3); /* wsptr[1,0],[1,1],[1,2],[1,3] */
1488 paddw_r2r(mm1, mm0); /* wsptr[0,tmp10],[xxx],[0,tmp13],[xxx] */
1489
1490 movq_m2r(*(wsptr+3), mm4); /* wsptr[1,4],[1,5],[1,6],[1,7] */
1491 psubw_r2r(mm1, mm2); /* wsptr[0,tmp11],[xxx],[0,tmp14],[xxx] */
1492
1493 movq_r2r(mm0, mm6);
1494 movq_r2r(mm3, mm5);
1495
1496 paddw_r2r(mm4, mm3); /* wsptr[1,tmp10],[xxx],[1,tmp13],[xxx] */
1497 movq_r2r(mm2, mm1);
1498
1499 psubw_r2r(mm4, mm5); /* wsptr[1,tmp11],[xxx],[1,tmp14],[xxx] */
1500 punpcklwd_r2r(mm3, mm0); /* wsptr[0,tmp10],[1,tmp10],[xxx],[xxx] */
1501
1502 movq_m2r(*(wsptr+7), mm7); /* wsptr[3,4],[3,5],[3,6],[3,7] */
1503 punpckhwd_r2r(mm3, mm6); /* wsptr[0,tmp13],[1,tmp13],[xxx],[xxx] */
1504
1505 movq_m2r(*(wsptr+4), mm3); /* wsptr[2,0],[2,1],[2,2],[2,3] */
1506 punpckldq_r2r(mm6, mm0); /* wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13] */
1507
1508 punpcklwd_r2r(mm5, mm1); /* wsptr[0,tmp11],[1,tmp11],[xxx],[xxx] */
1509 movq_r2r(mm3, mm4);
1510
1511 movq_m2r(*(wsptr+6), mm6); /* wsptr[3,0],[3,1],[3,2],[3,3] */
1512 punpckhwd_r2r(mm5, mm2); /* wsptr[0,tmp14],[1,tmp14],[xxx],[xxx] */
1513
1514 movq_m2r(*(wsptr+5), mm5); /* wsptr[2,4],[2,5],[2,6],[2,7] */
1515 punpckldq_r2r(mm2, mm1); /* wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14] */
1516
1517
1518 paddw_r2r(mm5, mm3); /* wsptr[2,tmp10],[xxx],[2,tmp13],[xxx] */
1519 movq_r2r(mm6, mm2);
1520
1521 psubw_r2r(mm5, mm4); /* wsptr[2,tmp11],[xxx],[2,tmp14],[xxx] */
1522 paddw_r2r(mm7, mm6); /* wsptr[3,tmp10],[xxx],[3,tmp13],[xxx] */
1523
1524 movq_r2r(mm3, mm5);
1525 punpcklwd_r2r(mm6, mm3); /* wsptr[2,tmp10],[3,tmp10],[xxx],[xxx] */
1526
1527 psubw_r2r(mm7, mm2); /* wsptr[3,tmp11],[xxx],[3,tmp14],[xxx] */
1528 punpckhwd_r2r(mm6, mm5); /* wsptr[2,tmp13],[3,tmp13],[xxx],[xxx] */
1529
1530 movq_r2r(mm4, mm7);
1531 punpckldq_r2r(mm5, mm3); /* wsptr[2,tmp10],[3,tmp10],[2,tmp13],[3,tmp13] */
1532
1533 punpcklwd_r2r(mm2, mm4); /* wsptr[2,tmp11],[3,tmp11],[xxx],[xxx] */
1534
1535 punpckhwd_r2r(mm2, mm7); /* wsptr[2,tmp14],[3,tmp14],[xxx],[xxx] */
1536
1537 punpckldq_r2r(mm7, mm4); /* wsptr[2,tmp11],[3,tmp11],[2,tmp14],[3,tmp14] */
1538 movq_r2r(mm1, mm6);
1539
1540 /*ok */
1541
1542 /* mm0 = ;wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13] */
1543 /* mm1 = ;wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14] */
1544
1545
1546 movq_r2r(mm0, mm2);
1547 punpckhdq_r2r(mm4, mm6); /* wsptr[0,tmp14],[1,tmp14],[2,tmp14],[3,tmp14] */
1548
1549 punpckldq_r2r(mm4, mm1); /* wsptr[0,tmp11],[1,tmp11],[2,tmp11],[3,tmp11] */
1550 psllw_i2r(2, mm6);
1551
1552 pmulhw_m2r(fix_141, mm6);
1553 punpckldq_r2r(mm3, mm0); /* wsptr[0,tmp10],[1,tmp10],[2,tmp10],[3,tmp10] */
1554
1555 punpckhdq_r2r(mm3, mm2); /* wsptr[0,tmp13],[1,tmp13],[2,tmp13],[3,tmp13] */
1556 movq_r2r(mm0, mm7);
1557
1558 /* tmp0 = tmp10 + tmp13; */
1559 /* tmp3 = tmp10 - tmp13; */
1560 paddw_r2r(mm2, mm0); /* [0,tmp0],[1,tmp0],[2,tmp0],[3,tmp0] */
1561 psubw_r2r(mm2, mm7); /* [0,tmp3],[1,tmp3],[2,tmp3],[3,tmp3] */
1562
1563 /* tmp12 = MULTIPLY(tmp14, FIX_1_414213562) - tmp13; */
1564 psubw_r2r(mm2, mm6); /* wsptr[0,tmp12],[1,tmp12],[2,tmp12],[3,tmp12] */
1565 /* tmp1 = tmp11 + tmp12; */
1566 /* tmp2 = tmp11 - tmp12; */
1567 movq_r2r(mm1, mm5);
1568
1569 /*OK */
1570
1571 /* Odd part */
1572
1573 /* z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3]; */
1574 /* z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3]; */
1575 /* z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7]; */
1576 /* z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7]; */
1577 movq_m2r(*(wsptr), mm3); /* wsptr[0,0],[0,1],[0,2],[0,3] */
1578 paddw_r2r(mm6, mm1); /* [0,tmp1],[1,tmp1],[2,tmp1],[3,tmp1] */
1579
1580 movq_m2r(*(wsptr+1), mm4); /* wsptr[0,4],[0,5],[0,6],[0,7] */
1581 psubw_r2r(mm6, mm5); /* [0,tmp2],[1,tmp2],[2,tmp2],[3,tmp2] */
1582
1583 movq_r2r(mm3, mm6);
1584 punpckldq_r2r(mm4, mm3); /* wsptr[0,0],[0,1],[0,4],[0,5] */
1585
1586 punpckhdq_r2r(mm6, mm4); /* wsptr[0,6],[0,7],[0,2],[0,3] */
1587 movq_r2r(mm3, mm2);
1588
1589 /*Save tmp0 and tmp1 in wsptr */
1590 movq_r2m(mm0, *(wsptr)); /* save tmp0 */
1591 paddw_r2r(mm4, mm2); /* wsptr[xxx],[0,z11],[xxx],[0,z13] */
1592
1593
1594 /*Continue with z10 --- z13 */
1595 movq_m2r(*(wsptr+2), mm6); /* wsptr[1,0],[1,1],[1,2],[1,3] */
1596 psubw_r2r(mm4, mm3); /* wsptr[xxx],[0,z12],[xxx],[0,z10] */
1597
1598 movq_m2r(*(wsptr+3), mm0); /* wsptr[1,4],[1,5],[1,6],[1,7] */
1599 movq_r2r(mm6, mm4);
1600
1601 movq_r2m(mm1, *(wsptr+1)); /* save tmp1 */
1602 punpckldq_r2r(mm0, mm6); /* wsptr[1,0],[1,1],[1,4],[1,5] */
1603
1604 punpckhdq_r2r(mm4, mm0); /* wsptr[1,6],[1,7],[1,2],[1,3] */
1605 movq_r2r(mm6, mm1);
1606
1607 /*Save tmp2 and tmp3 in wsptr */
1608 paddw_r2r(mm0, mm6); /* wsptr[xxx],[1,z11],[xxx],[1,z13] */
1609 movq_r2r(mm2, mm4);
1610
1611 /*Continue with z10 --- z13 */
1612 movq_r2m(mm5, *(wsptr+2)); /* save tmp2 */
1613 punpcklwd_r2r(mm6, mm2); /* wsptr[xxx],[xxx],[0,z11],[1,z11] */
1614
1615 psubw_r2r(mm0, mm1); /* wsptr[xxx],[1,z12],[xxx],[1,z10] */
1616 punpckhwd_r2r(mm6, mm4); /* wsptr[xxx],[xxx],[0,z13],[1,z13] */
1617
1618 movq_r2r(mm3, mm0);
1619 punpcklwd_r2r(mm1, mm3); /* wsptr[xxx],[xxx],[0,z12],[1,z12] */
1620
1621 movq_r2m(mm7, *(wsptr+3)); /* save tmp3 */
1622 punpckhwd_r2r(mm1, mm0); /* wsptr[xxx],[xxx],[0,z10],[1,z10] */
1623
1624 movq_m2r(*(wsptr+4), mm6); /* wsptr[2,0],[2,1],[2,2],[2,3] */
1625 punpckhdq_r2r(mm2, mm0); /* wsptr[0,z10],[1,z10],[0,z11],[1,z11] */
1626
1627 movq_m2r(*(wsptr+5), mm7); /* wsptr[2,4],[2,5],[2,6],[2,7] */
1628 punpckhdq_r2r(mm4, mm3); /* wsptr[0,z12],[1,z12],[0,z13],[1,z13] */
1629
1630 movq_m2r(*(wsptr+6), mm1); /* wsptr[3,0],[3,1],[3,2],[3,3] */
1631 movq_r2r(mm6, mm4);
1632
1633 punpckldq_r2r(mm7, mm6); /* wsptr[2,0],[2,1],[2,4],[2,5] */
1634 movq_r2r(mm1, mm5);
1635
1636 punpckhdq_r2r(mm4, mm7); /* wsptr[2,6],[2,7],[2,2],[2,3] */
1637 movq_r2r(mm6, mm2);
1638
1639 movq_m2r(*(wsptr+7), mm4); /* wsptr[3,4],[3,5],[3,6],[3,7] */
1640 paddw_r2r(mm7, mm6); /* wsptr[xxx],[2,z11],[xxx],[2,z13] */
1641
1642 psubw_r2r(mm7, mm2); /* wsptr[xxx],[2,z12],[xxx],[2,z10] */
1643 punpckldq_r2r(mm4, mm1); /* wsptr[3,0],[3,1],[3,4],[3,5] */
1644
1645 punpckhdq_r2r(mm5, mm4); /* wsptr[3,6],[3,7],[3,2],[3,3] */
1646 movq_r2r(mm1, mm7);
1647
1648 paddw_r2r(mm4, mm1); /* wsptr[xxx],[3,z11],[xxx],[3,z13] */
1649 psubw_r2r(mm4, mm7); /* wsptr[xxx],[3,z12],[xxx],[3,z10] */
1650
1651 movq_r2r(mm6, mm5);
1652 punpcklwd_r2r(mm1, mm6); /* wsptr[xxx],[xxx],[2,z11],[3,z11] */
1653
1654 punpckhwd_r2r(mm1, mm5); /* wsptr[xxx],[xxx],[2,z13],[3,z13] */
1655 movq_r2r(mm2, mm4);
1656
1657 punpcklwd_r2r(mm7, mm2); /* wsptr[xxx],[xxx],[2,z12],[3,z12] */
1658
1659 punpckhwd_r2r(mm7, mm4); /* wsptr[xxx],[xxx],[2,z10],[3,z10] */
1660
1661 punpckhdq_r2r(mm6, mm4); /*/ wsptr[2,z10],[3,z10],[2,z11],[3,z11] */
1662
1663 punpckhdq_r2r(mm5, mm2); /* wsptr[2,z12],[3,z12],[2,z13],[3,z13] */
1664 movq_r2r(mm0, mm5);
1665
1666 punpckldq_r2r(mm4, mm0); /* wsptr[0,z10],[1,z10],[2,z10],[3,z10] */
1667
1668 punpckhdq_r2r(mm4, mm5); /* wsptr[0,z11],[1,z11],[2,z11],[3,z11] */
1669 movq_r2r(mm3, mm4);
1670
1671 punpckhdq_r2r(mm2, mm4); /* wsptr[0,z13],[1,z13],[2,z13],[3,z13] */
1672 movq_r2r(mm5, mm1);
1673
1674 punpckldq_r2r(mm2, mm3); /* wsptr[0,z12],[1,z12],[2,z12],[3,z12] */
1675 /* tmp7 = z11 + z13; /* phase 5 */ */
1676 /* tmp8 = z11 - z13; /* phase 5 */ */
1677 psubw_r2r(mm4, mm1); /* tmp8 */
1678
1679 paddw_r2r(mm4, mm5); /* tmp7 */
1680 /* tmp21 = MULTIPLY(tmp8, FIX_1_414213562); /* 2*c4 */ */
1681 psllw_i2r(2, mm1);
1682
1683 psllw_i2r(2, mm0);
1684
1685 pmulhw_m2r(fix_141, mm1); /* tmp21 */
1686 /* tmp20 = MULTIPLY(z12, (FIX_1_082392200- FIX_1_847759065)) /* 2*(c2-c6) */ */
1687 /* + MULTIPLY(z10, - FIX_1_847759065); /* 2*c2 */ */
1688 psllw_i2r(2, mm3);
1689 movq_r2r(mm0, mm7);
1690
1691 pmulhw_m2r(fix_n184, mm7);
1692 movq_r2r(mm3, mm6);
1693
1694 movq_m2r(*(wsptr), mm2); /* tmp0,final1 */
1695
1696 pmulhw_m2r(fix_108n184, mm6);
1697 /* tmp22 = MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) /* -2*(c2+c6) */ */
1698 /* + MULTIPLY(z12, FIX_1_847759065); /* 2*c2 */ */
1699 movq_r2r(mm2, mm4); /* final1 */
1700
1701 pmulhw_m2r(fix_184n261, mm0);
1702 paddw_r2r(mm5, mm2); /* tmp0+tmp7,final1 */
1703
1704 pmulhw_m2r(fix_184, mm3);
1705 psubw_r2r(mm5, mm4); /* tmp0-tmp7,final1 */
1706
1707 /* tmp6 = tmp22 - tmp7; /* phase 2 */ */
1708 psraw_i2r(3, mm2); /* outptr[0,0],[1,0],[2,0],[3,0],final1 */
1709
1710 paddw_r2r(mm6, mm7); /* tmp20 */
1711 psraw_i2r(3, mm4); /* outptr[0,7],[1,7],[2,7],[3,7],final1 */
1712
1713 paddw_r2r(mm0, mm3); /* tmp22 */
1714
1715 /* tmp5 = tmp21 - tmp6; */
1716 psubw_r2r(mm5, mm3); /* tmp6 */
1717
1718 /* tmp4 = tmp20 + tmp5; */
1719 movq_m2r(*(wsptr+1), mm0); /* tmp1,final2 */
1720 psubw_r2r(mm3, mm1); /* tmp5 */
1721
1722 movq_r2r(mm0, mm6); /* final2 */
1723 paddw_r2r(mm3, mm0); /* tmp1+tmp6,final2 */
1724
1725 /* Final output stage: scale down by a factor of 8 and range-limit */
1726
1727
1728 /* outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3) */
1729 /* & RANGE_MASK]; */
1730 /* outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3) */
1731 /* & RANGE_MASK]; final1 */
1732
1733
1734 /* outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3) */
1735 /* & RANGE_MASK]; */
1736 /* outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3) */
1737 /* & RANGE_MASK]; final2 */
1738 psubw_r2r(mm3, mm6); /* tmp1-tmp6,final2 */
1739 psraw_i2r(3, mm0); /* outptr[0,1],[1,1],[2,1],[3,1] */
1740
1741 psraw_i2r(3, mm6); /* outptr[0,6],[1,6],[2,6],[3,6] */
1742
1743 packuswb_r2r(mm4, mm0); /* out[0,1],[1,1],[2,1],[3,1],[0,7],[1,7],[2,7],[3,7] */
1744
1745 movq_m2r(*(wsptr+2), mm5); /* tmp2,final3 */
1746 packuswb_r2r(mm6, mm2); /* out[0,0],[1,0],[2,0],[3,0],[0,6],[1,6],[2,6],[3,6] */
1747
1748 /* outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3) */
1749 /* & RANGE_MASK]; */
1750 /* outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3) */
1751 /* & RANGE_MASK]; final3 */
1752 paddw_r2r(mm1, mm7); /* tmp4 */
1753 movq_r2r(mm5, mm3);
1754
1755 paddw_r2r(mm1, mm5); /* tmp2+tmp5 */
1756 psubw_r2r(mm1, mm3); /* tmp2-tmp5 */
1757
1758 psraw_i2r(3, mm5); /* outptr[0,2],[1,2],[2,2],[3,2] */
1759
1760 movq_m2r(*(wsptr+3), mm4); /* tmp3,final4 */
1761 psraw_i2r(3, mm3); /* outptr[0,5],[1,5],[2,5],[3,5] */
1762
1763
1764
1765 /* outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3) */
1766 /* & RANGE_MASK]; */
1767 /* outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3) */
1768 /* & RANGE_MASK]; final4 */
1769 movq_r2r(mm4, mm6);
1770 paddw_r2r(mm7, mm4); /* tmp3+tmp4 */
1771
1772 psubw_r2r(mm7, mm6); /* tmp3-tmp4 */
1773 psraw_i2r(3, mm4); /* outptr[0,4],[1,4],[2,4],[3,4] */
1774
1775 /* mov ecx, [dataptr] */
1776
1777 psraw_i2r(3, mm6); /* outptr[0,3],[1,3],[2,3],[3,3] */
1778
1779 packuswb_r2r(mm4, mm5); /* out[0,2],[1,2],[2,2],[3,2],[0,4],[1,4],[2,4],[3,4] */
1780
1781 packuswb_r2r(mm3, mm6); /* out[0,3],[1,3],[2,3],[3,3],[0,5],[1,5],[2,5],[3,5] */
1782 movq_r2r(mm2, mm4);
1783
1784 movq_r2r(mm5, mm7);
1785 punpcklbw_r2r(mm0, mm2); /* out[0,0],[0,1],[1,0],[1,1],[2,0],[2,1],[3,0],[3,1] */
1786
1787 punpckhbw_r2r(mm0, mm4); /* out[0,6],[0,7],[1,6],[1,7],[2,6],[2,7],[3,6],[3,7] */
1788 movq_r2r(mm2, mm1);
1789
1790 punpcklbw_r2r(mm6, mm5); /* out[0,2],[0,3],[1,2],[1,3],[2,2],[2,3],[3,2],[3,3] */
1791
1792 /* add dataptr, 4 */
1793
1794 punpckhbw_r2r(mm6, mm7); /* out[0,4],[0,5],[1,4],[1,5],[2,4],[2,5],[3,4],[3,5] */
1795
1796 punpcklwd_r2r(mm5, mm2); /* out[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3] */
1797
1798 /* add ecx, output_col */
1799
1800 movq_r2r(mm7, mm6);
1801 punpckhwd_r2r(mm5, mm1); /* out[2,0],[2,1],[2,2],[2,3],[3,0],[3,1],[3,2],[3,3] */
1802
1803 movq_r2r(mm2, mm0);
1804 punpcklwd_r2r(mm4, mm6); /* out[0,4],[0,5],[0,6],[0,7],[1,4],[1,5],[1,6],[1,7] */
1805
1806 /* mov idata, [dataptr] */
1807
1808 punpckldq_r2r(mm6, mm2); /* out[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7] */
1809
1810 /* add dataptr, 4 */
1811
1812 movq_r2r(mm1, mm3);
1813
1814 /* add idata, output_col */
1815
1816 punpckhwd_r2r(mm4, mm7); /* out[2,4],[2,5],[2,6],[2,7],[3,4],[3,5],[3,6],[3,7] */
1817
1818 movq_r2m(mm2, *(dataptr));
1819
1820 punpckhdq_r2r(mm6, mm0); /* out[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7] */
1821
1822 dataptr += rskip;
1823 movq_r2m(mm0, *(dataptr));
1824
1825 punpckldq_r2r(mm7, mm1); /* out[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7] */
1826 punpckhdq_r2r(mm7, mm3); /* out[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7] */
1827
1828 dataptr += rskip;
1829 movq_r2m(mm1, *(dataptr));
1830
1831 dataptr += rskip;
1832 movq_r2m(mm3, *(dataptr));
1833
1834 /*******************************************************************/
1835
1836 wsptr += 8;
1837
1838 /*******************************************************************/
1839
1840 /* tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]); */
1841 /* tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]); */
1842 /* tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]); */
1843 /* tmp14 = ((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6]); */
1844 movq_m2r(*(wsptr), mm0); /* wsptr[0,0],[0,1],[0,2],[0,3] */
1845
1846 movq_m2r(*(wsptr+1), mm1); /* wsptr[0,4],[0,5],[0,6],[0,7] */
1847 movq_r2r(mm0, mm2);
1848
1849 movq_m2r(*(wsptr+2), mm3); /* wsptr[1,0],[1,1],[1,2],[1,3] */
1850 paddw_r2r(mm1, mm0); /* wsptr[0,tmp10],[xxx],[0,tmp13],[xxx] */
1851
1852 movq_m2r(*(wsptr+3), mm4); /* wsptr[1,4],[1,5],[1,6],[1,7] */
1853 psubw_r2r(mm1, mm2); /* wsptr[0,tmp11],[xxx],[0,tmp14],[xxx] */
1854
1855 movq_r2r(mm0, mm6);
1856 movq_r2r(mm3, mm5);
1857
1858 paddw_r2r(mm4, mm3); /* wsptr[1,tmp10],[xxx],[1,tmp13],[xxx] */
1859 movq_r2r(mm2, mm1);
1860
1861 psubw_r2r(mm4, mm5); /* wsptr[1,tmp11],[xxx],[1,tmp14],[xxx] */
1862 punpcklwd_r2r(mm3, mm0); /* wsptr[0,tmp10],[1,tmp10],[xxx],[xxx] */
1863
1864 movq_m2r(*(wsptr+7), mm7); /* wsptr[3,4],[3,5],[3,6],[3,7] */
1865 punpckhwd_r2r(mm3, mm6); /* wsptr[0,tmp13],[1,tmp13],[xxx],[xxx] */
1866
1867 movq_m2r(*(wsptr+4), mm3); /* wsptr[2,0],[2,1],[2,2],[2,3] */
1868 punpckldq_r2r(mm6, mm0); /* wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13] */
1869
1870 punpcklwd_r2r(mm5, mm1); /* wsptr[0,tmp11],[1,tmp11],[xxx],[xxx] */
1871 movq_r2r(mm3, mm4);
1872
1873 movq_m2r(*(wsptr+6), mm6); /* wsptr[3,0],[3,1],[3,2],[3,3] */
1874 punpckhwd_r2r(mm5, mm2); /* wsptr[0,tmp14],[1,tmp14],[xxx],[xxx] */
1875
1876 movq_m2r(*(wsptr+5), mm5); /* wsptr[2,4],[2,5],[2,6],[2,7] */
1877 punpckldq_r2r(mm2, mm1); /* wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14] */
1878
1879 paddw_r2r(mm5, mm3); /* wsptr[2,tmp10],[xxx],[2,tmp13],[xxx] */
1880 movq_r2r(mm6, mm2);
1881
1882 psubw_r2r(mm5, mm4); /* wsptr[2,tmp11],[xxx],[2,tmp14],[xxx] */
1883 paddw_r2r(mm7, mm6); /* wsptr[3,tmp10],[xxx],[3,tmp13],[xxx] */
1884
1885 movq_r2r(mm3, mm5);
1886 punpcklwd_r2r(mm6, mm3); /* wsptr[2,tmp10],[3,tmp10],[xxx],[xxx] */
1887
1888 psubw_r2r(mm7, mm2); /* wsptr[3,tmp11],[xxx],[3,tmp14],[xxx] */
1889 punpckhwd_r2r(mm6, mm5); /* wsptr[2,tmp13],[3,tmp13],[xxx],[xxx] */
1890
1891 movq_r2r(mm4, mm7);
1892 punpckldq_r2r(mm5, mm3); /* wsptr[2,tmp10],[3,tmp10],[2,tmp13],[3,tmp13] */
1893
1894 punpcklwd_r2r(mm2, mm4); /* wsptr[2,tmp11],[3,tmp11],[xxx],[xxx] */
1895
1896 punpckhwd_r2r(mm2, mm7); /* wsptr[2,tmp14],[3,tmp14],[xxx],[xxx] */
1897
1898 punpckldq_r2r(mm7, mm4); /* wsptr[2,tmp11],[3,tmp11],[2,tmp14],[3,tmp14] */
1899 movq_r2r(mm1, mm6);
1900
1901 /*OK */
1902
1903 /* mm0 = ;wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13] */
1904 /* mm1 = ;wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14] */
1905
1906 movq_r2r(mm0, mm2);
1907 punpckhdq_r2r(mm4, mm6); /* wsptr[0,tmp14],[1,tmp14],[2,tmp14],[3,tmp14] */
1908
1909 punpckldq_r2r(mm4, mm1); /* wsptr[0,tmp11],[1,tmp11],[2,tmp11],[3,tmp11] */
1910 psllw_i2r(2, mm6);
1911
1912 pmulhw_m2r(fix_141, mm6);
1913 punpckldq_r2r(mm3, mm0); /* wsptr[0,tmp10],[1,tmp10],[2,tmp10],[3,tmp10] */
1914
1915 punpckhdq_r2r(mm3, mm2); /* wsptr[0,tmp13],[1,tmp13],[2,tmp13],[3,tmp13] */
1916 movq_r2r(mm0, mm7);
1917
1918 /* tmp0 = tmp10 + tmp13; */
1919 /* tmp3 = tmp10 - tmp13; */
1920 paddw_r2r(mm2, mm0); /* [0,tmp0],[1,tmp0],[2,tmp0],[3,tmp0] */
1921 psubw_r2r(mm2, mm7); /* [0,tmp3],[1,tmp3],[2,tmp3],[3,tmp3] */
1922
1923 /* tmp12 = MULTIPLY(tmp14, FIX_1_414213562) - tmp13; */
1924 psubw_r2r(mm2, mm6); /* wsptr[0,tmp12],[1,tmp12],[2,tmp12],[3,tmp12] */
1925 /* tmp1 = tmp11 + tmp12; */
1926 /* tmp2 = tmp11 - tmp12; */
1927 movq_r2r(mm1, mm5);
1928
1929 /*OK */
1930
1931
1932 /* Odd part */
1933
1934 /* z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3]; */
1935 /* z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3]; */
1936 /* z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7]; */
1937 /* z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7]; */
1938 movq_m2r(*(wsptr), mm3); /* wsptr[0,0],[0,1],[0,2],[0,3] */
1939 paddw_r2r(mm6, mm1); /* [0,tmp1],[1,tmp1],[2,tmp1],[3,tmp1] */
1940
1941 movq_m2r(*(wsptr+1), mm4); /* wsptr[0,4],[0,5],[0,6],[0,7] */
1942 psubw_r2r(mm6, mm5); /* [0,tmp2],[1,tmp2],[2,tmp2],[3,tmp2] */
1943
1944 movq_r2r(mm3, mm6);
1945 punpckldq_r2r(mm4, mm3); /* wsptr[0,0],[0,1],[0,4],[0,5] */
1946
1947 punpckhdq_r2r(mm6, mm4); /* wsptr[0,6],[0,7],[0,2],[0,3] */
1948 movq_r2r(mm3, mm2);
1949
1950 /*Save tmp0 and tmp1 in wsptr */
1951 movq_r2m(mm0, *(wsptr)); /* save tmp0 */
1952 paddw_r2r(mm4, mm2); /* wsptr[xxx],[0,z11],[xxx],[0,z13] */
1953
1954
1955 /*Continue with z10 --- z13 */
1956 movq_m2r(*(wsptr+2), mm6); /* wsptr[1,0],[1,1],[1,2],[1,3] */
1957 psubw_r2r(mm4, mm3); /* wsptr[xxx],[0,z12],[xxx],[0,z10] */
1958
1959 movq_m2r(*(wsptr+3), mm0); /* wsptr[1,4],[1,5],[1,6],[1,7] */
1960 movq_r2r(mm6, mm4);
1961
1962 movq_r2m(mm1, *(wsptr+1)); /* save tmp1 */
1963 punpckldq_r2r(mm0, mm6); /* wsptr[1,0],[1,1],[1,4],[1,5] */
1964
1965 punpckhdq_r2r(mm4, mm0); /* wsptr[1,6],[1,7],[1,2],[1,3] */
1966 movq_r2r(mm6, mm1);
1967
1968 /*Save tmp2 and tmp3 in wsptr */
1969 paddw_r2r(mm0, mm6); /* wsptr[xxx],[1,z11],[xxx],[1,z13] */
1970 movq_r2r(mm2, mm4);
1971
1972 /*Continue with z10 --- z13 */
1973 movq_r2m(mm5, *(wsptr+2)); /* save tmp2 */
1974 punpcklwd_r2r(mm6, mm2); /* wsptr[xxx],[xxx],[0,z11],[1,z11] */
1975
1976 psubw_r2r(mm0, mm1); /* wsptr[xxx],[1,z12],[xxx],[1,z10] */
1977 punpckhwd_r2r(mm6, mm4); /* wsptr[xxx],[xxx],[0,z13],[1,z13] */
1978
1979 movq_r2r(mm3, mm0);
1980 punpcklwd_r2r(mm1, mm3); /* wsptr[xxx],[xxx],[0,z12],[1,z12] */
1981
1982 movq_r2m(mm7, *(wsptr+3)); /* save tmp3 */
1983 punpckhwd_r2r(mm1, mm0); /* wsptr[xxx],[xxx],[0,z10],[1,z10] */
1984
1985 movq_m2r(*(wsptr+4), mm6); /* wsptr[2,0],[2,1],[2,2],[2,3] */
1986 punpckhdq_r2r(mm2, mm0); /* wsptr[0,z10],[1,z10],[0,z11],[1,z11] */
1987
1988 movq_m2r(*(wsptr+5), mm7); /* wsptr[2,4],[2,5],[2,6],[2,7] */
1989 punpckhdq_r2r(mm4, mm3); /* wsptr[0,z12],[1,z12],[0,z13],[1,z13] */
1990
1991 movq_m2r(*(wsptr+6), mm1); /* wsptr[3,0],[3,1],[3,2],[3,3] */
1992 movq_r2r(mm6, mm4);
1993
1994 punpckldq_r2r(mm7, mm6); /* wsptr[2,0],[2,1],[2,4],[2,5] */
1995 movq_r2r(mm1, mm5);
1996
1997 punpckhdq_r2r(mm4, mm7); /* wsptr[2,6],[2,7],[2,2],[2,3] */
1998 movq_r2r(mm6, mm2);
1999
2000 movq_m2r(*(wsptr+7), mm4); /* wsptr[3,4],[3,5],[3,6],[3,7] */
2001 paddw_r2r(mm7, mm6); /* wsptr[xxx],[2,z11],[xxx],[2,z13] */
2002
2003 psubw_r2r(mm7, mm2); /* wsptr[xxx],[2,z12],[xxx],[2,z10] */
2004 punpckldq_r2r(mm4, mm1); /* wsptr[3,0],[3,1],[3,4],[3,5] */
2005
2006 punpckhdq_r2r(mm5, mm4); /* wsptr[3,6],[3,7],[3,2],[3,3] */
2007 movq_r2r(mm1, mm7);
2008
2009 paddw_r2r(mm4, mm1); /* wsptr[xxx],[3,z11],[xxx],[3,z13] */
2010 psubw_r2r(mm4, mm7); /* wsptr[xxx],[3,z12],[xxx],[3,z10] */
2011
2012 movq_r2r(mm6, mm5);
2013 punpcklwd_r2r(mm1, mm6); /* wsptr[xxx],[xxx],[2,z11],[3,z11] */
2014
2015 punpckhwd_r2r(mm1, mm5); /* wsptr[xxx],[xxx],[2,z13],[3,z13] */
2016 movq_r2r(mm2, mm4);
2017
2018 punpcklwd_r2r(mm7, mm2); /* wsptr[xxx],[xxx],[2,z12],[3,z12] */
2019
2020 punpckhwd_r2r(mm7, mm4); /* wsptr[xxx],[xxx],[2,z10],[3,z10] */
2021
2022 punpckhdq_r2r(mm6, mm4); /* wsptr[2,z10],[3,z10],[2,z11],[3,z11] */
2023
2024 punpckhdq_r2r(mm5, mm2); /* wsptr[2,z12],[3,z12],[2,z13],[3,z13] */
2025 movq_r2r(mm0, mm5);
2026
2027 punpckldq_r2r(mm4, mm0); /* wsptr[0,z10],[1,z10],[2,z10],[3,z10] */
2028
2029 punpckhdq_r2r(mm4, mm5); /* wsptr[0,z11],[1,z11],[2,z11],[3,z11] */
2030 movq_r2r(mm3, mm4);
2031
2032 punpckhdq_r2r(mm2, mm4); /* wsptr[0,z13],[1,z13],[2,z13],[3,z13] */
2033 movq_r2r(mm5, mm1);
2034
2035 punpckldq_r2r(mm2, mm3); /* wsptr[0,z12],[1,z12],[2,z12],[3,z12] */
2036 /* tmp7 = z11 + z13; /* phase 5 */ */
2037 /* tmp8 = z11 - z13; /* phase 5 */ */
2038 psubw_r2r(mm4, mm1); /* tmp8 */
2039
2040 paddw_r2r(mm4, mm5); /* tmp7 */
2041 /* tmp21 = MULTIPLY(tmp8, FIX_1_414213562); /* 2*c4 */ */
2042 psllw_i2r(2, mm1);
2043
2044 psllw_i2r(2, mm0);
2045
2046 pmulhw_m2r(fix_141, mm1); /* tmp21 */
2047 /* tmp20 = MULTIPLY(z12, (FIX_1_082392200- FIX_1_847759065)) /* 2*(c2-c6) */ */
2048 /* + MULTIPLY(z10, - FIX_1_847759065); /* 2*c2 */ */
2049 psllw_i2r(2, mm3);
2050 movq_r2r(mm0, mm7);
2051
2052 pmulhw_m2r(fix_n184, mm7);
2053 movq_r2r(mm3, mm6);
2054
2055 movq_m2r(*(wsptr), mm2); /* tmp0,final1 */
2056
2057 pmulhw_m2r(fix_108n184, mm6);
2058 /* tmp22 = MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) /* -2*(c2+c6) */ */
2059 /* + MULTIPLY(z12, FIX_1_847759065); /* 2*c2 */ */
2060 movq_r2r(mm2, mm4); /* final1 */
2061
2062 pmulhw_m2r(fix_184n261, mm0);
2063 paddw_r2r(mm5, mm2); /* tmp0+tmp7,final1 */
2064
2065 pmulhw_m2r(fix_184, mm3);
2066 psubw_r2r(mm5, mm4); /* tmp0-tmp7,final1 */
2067
2068 /* tmp6 = tmp22 - tmp7; /* phase 2 */ */
2069 psraw_i2r(3, mm2); /* outptr[0,0],[1,0],[2,0],[3,0],final1 */
2070
2071 paddw_r2r(mm6, mm7); /* tmp20 */
2072 psraw_i2r(3, mm4); /* outptr[0,7],[1,7],[2,7],[3,7],final1 */
2073
2074 paddw_r2r(mm0, mm3); /* tmp22 */
2075
2076 /* tmp5 = tmp21 - tmp6; */
2077 psubw_r2r(mm5, mm3); /* tmp6 */
2078
2079 /* tmp4 = tmp20 + tmp5; */
2080 movq_m2r(*(wsptr+1), mm0); /* tmp1,final2 */
2081 psubw_r2r(mm3, mm1); /* tmp5 */
2082
2083 movq_r2r(mm0, mm6); /* final2 */
2084 paddw_r2r(mm3, mm0); /* tmp1+tmp6,final2 */
2085
2086 /* Final output stage: scale down by a factor of 8 and range-limit */
2087
2088 /* outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3) */
2089 /* & RANGE_MASK]; */
2090 /* outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3) */
2091 /* & RANGE_MASK]; final1 */
2092
2093
2094 /* outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3) */
2095 /* & RANGE_MASK]; */
2096 /* outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3) */
2097 /* & RANGE_MASK]; final2 */
2098 psubw_r2r(mm3, mm6); /* tmp1-tmp6,final2 */
2099 psraw_i2r(3, mm0); /* outptr[0,1],[1,1],[2,1],[3,1] */
2100
2101 psraw_i2r(3, mm6); /* outptr[0,6],[1,6],[2,6],[3,6] */
2102
2103 packuswb_r2r(mm4, mm0); /* out[0,1],[1,1],[2,1],[3,1],[0,7],[1,7],[2,7],[3,7] */
2104
2105 movq_m2r(*(wsptr+2), mm5); /* tmp2,final3 */
2106 packuswb_r2r(mm6, mm2); /* out[0,0],[1,0],[2,0],[3,0],[0,6],[1,6],[2,6],[3,6] */
2107
2108 /* outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3) */
2109 /* & RANGE_MASK]; */
2110 /* outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3) */
2111 /* & RANGE_MASK]; final3 */
2112 paddw_r2r(mm1, mm7); /* tmp4 */
2113 movq_r2r(mm5, mm3);
2114
2115 paddw_r2r(mm1, mm5); /* tmp2+tmp5 */
2116 psubw_r2r(mm1, mm3); /* tmp2-tmp5 */
2117
2118 psraw_i2r(3, mm5); /* outptr[0,2],[1,2],[2,2],[3,2] */
2119
2120 movq_m2r(*(wsptr+3), mm4); /* tmp3,final4 */
2121 psraw_i2r(3, mm3); /* outptr[0,5],[1,5],[2,5],[3,5] */
2122
2123
2124
2125 /* outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3) */
2126 /* & RANGE_MASK]; */
2127 /* outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3) */
2128 /* & RANGE_MASK]; final4 */
2129 movq_r2r(mm4, mm6);
2130 paddw_r2r(mm7, mm4); /* tmp3+tmp4 */
2131
2132 psubw_r2r(mm7, mm6); /* tmp3-tmp4 */
2133 psraw_i2r(3, mm4); /* outptr[0,4],[1,4],[2,4],[3,4] */
2134
2135 psraw_i2r(3, mm6); /* outptr[0,3],[1,3],[2,3],[3,3] */
2136
2137 /*
2138 movq_r2m(mm4, *dummy);
2139 fprintf(stderr, "3-4 %016llx\n", dummy);
2140 movq_r2m(mm4, *dummy);
2141 fprintf(stderr, "3+4 %016llx\n", dummy);
2142 */
2143
2144
2145 packuswb_r2r(mm4, mm5); /* out[0,2],[1,2],[2,2],[3,2],[0,4],[1,4],[2,4],[3,4] */
2146
2147 packuswb_r2r(mm3, mm6); /* out[0,3],[1,3],[2,3],[3,3],[0,5],[1,5],[2,5],[3,5] */
2148 movq_r2r(mm2, mm4);
2149
2150 movq_r2r(mm5, mm7);
2151 punpcklbw_r2r(mm0, mm2); /* out[0,0],[0,1],[1,0],[1,1],[2,0],[2,1],[3,0],[3,1] */
2152
2153 punpckhbw_r2r(mm0, mm4); /* out[0,6],[0,7],[1,6],[1,7],[2,6],[2,7],[3,6],[3,7] */
2154 movq_r2r(mm2, mm1);
2155
2156 punpcklbw_r2r(mm6, mm5); /* out[0,2],[0,3],[1,2],[1,3],[2,2],[2,3],[3,2],[3,3] */
2157
2158 punpckhbw_r2r(mm6, mm7); /* out[0,4],[0,5],[1,4],[1,5],[2,4],[2,5],[3,4],[3,5] */
2159
2160 punpcklwd_r2r(mm5, mm2); /* out[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3] */
2161
2162 movq_r2r(mm7, mm6);
2163 punpckhwd_r2r(mm5, mm1); /* out[2,0],[2,1],[2,2],[2,3],[3,0],[3,1],[3,2],[3,3] */
2164
2165 movq_r2r(mm2, mm0);
2166 punpcklwd_r2r(mm4, mm6); /* out[0,4],[0,5],[0,6],[0,7],[1,4],[1,5],[1,6],[1,7] */
2167
2168 punpckldq_r2r(mm6, mm2); /* out[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7] */
2169
2170 movq_r2r(mm1, mm3);
2171
2172 punpckhwd_r2r(mm4, mm7); /* out[2,4],[2,5],[2,6],[2,7],[3,4],[3,5],[3,6],[3,7] */
2173
2174 dataptr += rskip;
2175 movq_r2m(mm2, *(dataptr));
2176
2177 punpckhdq_r2r(mm6, mm0); /* out[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7] */
2178
2179 dataptr += rskip;
2180 movq_r2m(mm0, *(dataptr));
2181
2182 punpckldq_r2r(mm7, mm1); /* out[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7] */
2183
2184 punpckhdq_r2r(mm7, mm3); /* out[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7] */
2185
2186 dataptr += rskip;
2187 movq_r2m(mm1, *(dataptr));
2188
2189 dataptr += rskip;
2190 movq_r2m(mm3, *(dataptr));
2191
2192 #else
2193 __s32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2194 __s32 tmp10, tmp11, tmp12, tmp13;
2195 __s32 z5, z10, z11, z12, z13;
2196 __s16 *inptr;
2197 __s32 *wsptr;
2198 __u8 *outptr;
2199 int ctr;
2200 __s32 dcval;
2201 __s32 workspace[64];
2202
2203 inptr = data;
2204 wsptr = workspace;
2205 for (ctr = 8; ctr > 0; ctr--) {
2206
2207 if ((inptr[8] | inptr[16] | inptr[24] |
2208 inptr[32] | inptr[40] | inptr[48] | inptr[56]) == 0) {
2209 dcval = inptr[0];
2210 wsptr[0] = dcval;
2211 wsptr[8] = dcval;
2212 wsptr[16] = dcval;
2213 wsptr[24] = dcval;
2214 wsptr[32] = dcval;
2215 wsptr[40] = dcval;
2216 wsptr[48] = dcval;
2217 wsptr[56] = dcval;
2218
2219 inptr++;
2220 wsptr++;
2221 continue;
2222 }
2223
2224 tmp0 = inptr[0];
2225 tmp1 = inptr[16];
2226 tmp2 = inptr[32];
2227 tmp3 = inptr[48];
2228
2229 tmp10 = tmp0 + tmp2;
2230 tmp11 = tmp0 - tmp2;
2231
2232 tmp13 = tmp1 + tmp3;
2233 tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13;
2234
2235 tmp0 = tmp10 + tmp13;
2236 tmp3 = tmp10 - tmp13;
2237 tmp1 = tmp11 + tmp12;
2238 tmp2 = tmp11 - tmp12;
2239
2240 tmp4 = inptr[8];
2241 tmp5 = inptr[24];
2242 tmp6 = inptr[40];
2243 tmp7 = inptr[56];
2244
2245 z13 = tmp6 + tmp5;
2246 z10 = tmp6 - tmp5;
2247 z11 = tmp4 + tmp7;
2248 z12 = tmp4 - tmp7;
2249
2250 tmp7 = z11 + z13;
2251 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
2252
2253 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
2254 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
2255 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
2256
2257 tmp6 = tmp12 - tmp7;
2258 tmp5 = tmp11 - tmp6;
2259 tmp4 = tmp10 + tmp5;
2260
2261 wsptr[0] = (__s32) (tmp0 + tmp7);
2262 wsptr[56] = (__s32) (tmp0 - tmp7);
2263 wsptr[8] = (__s32) (tmp1 + tmp6);
2264 wsptr[48] = (__s32) (tmp1 - tmp6);
2265 wsptr[16] = (__s32) (tmp2 + tmp5);
2266 wsptr[40] = (__s32) (tmp2 - tmp5);
2267 wsptr[32] = (__s32) (tmp3 + tmp4);
2268 wsptr[24] = (__s32) (tmp3 - tmp4);
2269
2270 inptr++;
2271 wsptr++;
2272 }
2273
2274 wsptr = workspace;
2275 for (ctr = 0; ctr < 8; ctr++) {
2276 outptr = &(odata[ctr*rskip]);
2277
2278 tmp10 = wsptr[0] + wsptr[4];
2279 tmp11 = wsptr[0] - wsptr[4];
2280
2281 tmp13 = wsptr[2] + wsptr[6];
2282 tmp12 = MULTIPLY(wsptr[2] - wsptr[6], FIX_1_414213562) - tmp13;
2283
2284 tmp0 = tmp10 + tmp13;
2285 tmp3 = tmp10 - tmp13;
2286 tmp1 = tmp11 + tmp12;
2287 tmp2 = tmp11 - tmp12;
2288
2289 z13 = wsptr[5] + wsptr[3];
2290 z10 = wsptr[5] - wsptr[3];
2291 z11 = wsptr[1] + wsptr[7];
2292 z12 = wsptr[1] - wsptr[7];
2293
2294 tmp7 = z11 + z13;
2295 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
2296
2297 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
2298 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
2299 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
2300
2301 tmp6 = tmp12 - tmp7;
2302 tmp5 = tmp11 - tmp6;
2303 tmp4 = tmp10 + tmp5;
2304
2305 outptr[0] = RL(DESCALE(tmp0 + tmp7));
2306 outptr[7] = RL(DESCALE(tmp0 - tmp7));
2307 outptr[1] = RL(DESCALE(tmp1 + tmp6));
2308 outptr[6] = RL(DESCALE(tmp1 - tmp6));
2309 outptr[2] = RL(DESCALE(tmp2 + tmp5));
2310 outptr[5] = RL(DESCALE(tmp2 - tmp5));
2311 outptr[4] = RL(DESCALE(tmp3 + tmp4));
2312 outptr[3] = RL(DESCALE(tmp3 - tmp4));
2313
2314 wsptr += 8;
2315 }
2316 #endif
2317 }
2318 /*
2319
2320 Main Routines
2321
2322 This file contains most of the initialisation and control functions
2323
2324 (C) Justin Schoeman 1998
2325
2326 */
2327
2328 /*
2329
2330 Private function
2331
2332 Initialise all the cache-aliged data blocks
2333
2334 */
2335
2336 void RTjpeg_init_data(void)
2337 {
2338 unsigned long dptr;
2339
2340 dptr=(unsigned long)&(RTjpeg_alldata[0]);
2341 dptr+=32;
2342 dptr=dptr>>5;
2343 dptr=dptr<<5; /* cache align data */
2344
2345 RTjpeg_block=(__s16 *)dptr;
2346 dptr+=sizeof(__s16)*64;
2347 RTjpeg_lqt=(__s32 *)dptr;
2348 dptr+=sizeof(__s32)*64;
2349 RTjpeg_cqt=(__s32 *)dptr;
2350 dptr+=sizeof(__s32)*64;
2351 RTjpeg_liqt=(__u32 *)dptr;
2352 dptr+=sizeof(__u32)*64;
2353 RTjpeg_ciqt=(__u32 *)dptr;
2354 }
2355
2356 /*
2357
2358 External Function
2359
2360 Re-set quality factor
2361
2362 Input: buf -> pointer to 128 ints for quant values store to pass back to
2363 init_decompress.
2364 Q -> quality factor (192=best, 32=worst)
2365 */
2366
2367 void RTjpeg_init_Q(__u8 Q)
2368 {
2369 int i;
2370 __u64 qual;
2371
2372 qual=(__u64)Q<<(32-7); /* 32 bit FP, 255=2, 0=0 */
2373
2374 for(i=0; i<64; i++)
2375 {
2376 RTjpeg_lqt[i]=(__s32)((qual/((__u64)RTjpeg_lum_quant_tbl[i]<<16))>>3);
2377 if(RTjpeg_lqt[i]==0)RTjpeg_lqt[i]=1;
2378 RTjpeg_cqt[i]=(__s32)((qual/((__u64)RTjpeg_chrom_quant_tbl[i]<<16))>>3);
2379 if(RTjpeg_cqt[i]==0)RTjpeg_cqt[i]=1;
2380 RTjpeg_liqt[i]=(1<<16)/(RTjpeg_lqt[i]<<3);
2381 RTjpeg_ciqt[i]=(1<<16)/(RTjpeg_cqt[i]<<3);
2382 RTjpeg_lqt[i]=((1<<16)/RTjpeg_liqt[i])>>3;
2383 RTjpeg_cqt[i]=((1<<16)/RTjpeg_ciqt[i])>>3;
2384 }
2385
2386 RTjpeg_lb8=0;
2387 while(RTjpeg_liqt[RTjpeg_ZZ[++RTjpeg_lb8]]<=8);
2388 RTjpeg_lb8--;
2389 RTjpeg_cb8=0;
2390 while(RTjpeg_ciqt[RTjpeg_ZZ[++RTjpeg_cb8]]<=8);
2391 RTjpeg_cb8--;
2392
2393 RTjpeg_dct_init();
2394 RTjpeg_idct_init();
2395 RTjpeg_quant_init();
2396 }
2397
2398 /*
2399
2400 External Function
2401
2402 Initialise compression.
2403
2404 Input: buf -> pointer to 128 ints for quant values store to pass back to
2405 init_decompress.
2406 width -> width of image
2407 height -> height of image
2408 Q -> quality factor (192=best, 32=worst)
2409
2410 */
2411
2412 void RTjpeg_init_compress(__u32 *buf, int width, int height, __u8 Q)
2413 {
2414 int i;
2415 __u64 qual;
2416
2417 RTjpeg_init_data();
2418
2419 RTjpeg_width=width;
2420 RTjpeg_height=height;
2421 RTjpeg_Ywidth = RTjpeg_width>>3;
2422 RTjpeg_Ysize=width * height;
2423 RTjpeg_Cwidth = RTjpeg_width>>4;
2424 RTjpeg_Csize= (width>>1) * height;
2425
2426 qual=(__u64)Q<<(32-7); /* 32 bit FP, 255=2, 0=0 */
2427
2428 for(i=0; i<64; i++)
2429 {
2430 RTjpeg_lqt[i]=(__s32)((qual/((__u64)RTjpeg_lum_quant_tbl[i]<<16))>>3);
2431 if(RTjpeg_lqt[i]==0)RTjpeg_lqt[i]=1;
2432 RTjpeg_cqt[i]=(__s32)((qual/((__u64)RTjpeg_chrom_quant_tbl[i]<<16))>>3);
2433 if(RTjpeg_cqt[i]==0)RTjpeg_cqt[i]=1;
2434 RTjpeg_liqt[i]=(1<<16)/(RTjpeg_lqt[i]<<3);
2435 RTjpeg_ciqt[i]=(1<<16)/(RTjpeg_cqt[i]<<3);
2436 RTjpeg_lqt[i]=((1<<16)/RTjpeg_liqt[i])>>3;
2437 RTjpeg_cqt[i]=((1<<16)/RTjpeg_ciqt[i])>>3;
2438 }
2439
2440 RTjpeg_lb8=0;
2441 while(RTjpeg_liqt[RTjpeg_ZZ[++RTjpeg_lb8]]<=8);
2442 RTjpeg_lb8--;
2443 RTjpeg_cb8=0;
2444 while(RTjpeg_ciqt[RTjpeg_ZZ[++RTjpeg_cb8]]<=8);
2445 RTjpeg_cb8--;
2446
2447 RTjpeg_dct_init();
2448 RTjpeg_quant_init();
2449
2450 for(i=0; i<64; i++)
2451 buf[i]=RTjpeg_liqt[i];
2452 for(i=0; i<64; i++)
2453 buf[64+i]=RTjpeg_ciqt[i];
2454 }
2455
2456 void RTjpeg_init_decompress(__u32 *buf, int width, int height)
2457 {
2458 int i;
2459
2460 RTjpeg_init_data();
2461
2462 RTjpeg_width=width;
2463 RTjpeg_height=height;
2464 RTjpeg_Ywidth = RTjpeg_width>>3;
2465 RTjpeg_Ysize=width * height;
2466 RTjpeg_Cwidth = RTjpeg_width>>4;
2467 RTjpeg_Csize= (width>>1) * height;
2468
2469 for(i=0; i<64; i++)
2470 {
2471 RTjpeg_liqt[i]=buf[i];
2472 RTjpeg_ciqt[i]=buf[i+64];
2473 }
2474
2475 RTjpeg_lb8=0;
2476 while(RTjpeg_liqt[RTjpeg_ZZ[++RTjpeg_lb8]]<=8);
2477 RTjpeg_lb8--;
2478 RTjpeg_cb8=0;
2479 while(RTjpeg_ciqt[RTjpeg_ZZ[++RTjpeg_cb8]]<=8);
2480 RTjpeg_cb8--;
2481
2482 RTjpeg_idct_init();
2483
2484 /* RTjpeg_color_init(); */
2485 }
2486
2487 int RTjpeg_compressYUV420(__s8 *sp, unsigned char *bp)
2488 {
2489 __s8 * sb;
2490 register __s8 * bp1 = bp + (RTjpeg_width<<3);
2491 register __s8 * bp2 = bp + RTjpeg_Ysize;
2492 register __s8 * bp3 = bp2 + (RTjpeg_Csize>>1);
2493 register int i, j, k;
2494
2495 #ifdef USE_MMX
2496 emms();
2497 #endif
2498 sb=sp;
2499 /* Y */
2500 for(i=RTjpeg_height>>1; i; i-=8)
2501 {
2502 for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
2503 {
2504 RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
2505 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2506 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2507
2508 RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
2509 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2510 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2511
2512 RTjpeg_dctY(bp1+j, RTjpeg_block, RTjpeg_Ywidth);
2513 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2514 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2515
2516 RTjpeg_dctY(bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
2517 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2518 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2519
2520 RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
2521 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2522 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2523
2524 RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
2525 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2526 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2527
2528 }
2529 bp+=RTjpeg_width<<4;
2530 bp1+=RTjpeg_width<<4;
2531 bp2+=RTjpeg_width<<2;
2532 bp3+=RTjpeg_width<<2;
2533
2534 }
2535 #ifdef USE_MMX
2536 emms();
2537 #endif
2538 return (sp-sb);
2539 }
2540
2541 int RTjpeg_compressYUV422(__s8 *sp, unsigned char *bp)
2542 {
2543 __s8 * sb;
2544 register __s8 * bp2 = bp + RTjpeg_Ysize;
2545 register __s8 * bp3 = bp2 + RTjpeg_Csize;
2546 register int i, j, k;
2547
2548 #ifdef USE_MMX
2549 emms();
2550 #endif
2551 sb=sp;
2552 /* Y */
2553 for(i=RTjpeg_height; i; i-=8)
2554 {
2555 for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
2556 {
2557 RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
2558 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2559 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2560
2561 RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
2562 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2563 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2564
2565 RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
2566 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2567 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2568
2569 RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
2570 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2571 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2572
2573 }
2574 bp+=RTjpeg_width<<3;
2575 bp2+=RTjpeg_width<<2;
2576 bp3+=RTjpeg_width<<2;
2577
2578 }
2579 #ifdef USE_MMX
2580 emms();
2581 #endif
2582 return (sp-sb);
2583 }
2584
2585 int RTjpeg_compress8(__s8 *sp, unsigned char *bp)
2586 {
2587 __s8 * sb;
2588 int i, j;
2589
2590 #ifdef USE_MMX
2591 emms();
2592 #endif
2593
2594 sb=sp;
2595 /* Y */
2596 for(i=0; i<RTjpeg_height; i+=8)
2597 {
2598 for(j=0; j<RTjpeg_width; j+=8)
2599 {
2600 RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_width);
2601 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2602 sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2603 }
2604 bp+=RTjpeg_width;
2605 }
2606
2607 #ifdef USE_MMX
2608 emms();
2609 #endif
2610 return (sp-sb);
2611 }
2612
2613 void RTjpeg_decompressYUV422(__s8 *sp, __u8 *bp)
2614 {
2615 register __s8 * bp2 = bp + RTjpeg_Ysize;
2616 register __s8 * bp3 = bp2 + (RTjpeg_Csize);
2617 int i, j,k;
2618
2619 #ifdef USE_MMX
2620 emms();
2621 #endif
2622
2623 /* Y */
2624 for(i=RTjpeg_height; i; i-=8)
2625 {
2626 for(k=0, j=0; j<RTjpeg_width; j+=16, k+=8) {
2627 if(*sp==-1)sp++;
2628 else
2629 {
2630 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2631 RTjpeg_idct(bp+j, RTjpeg_block, RTjpeg_width);
2632 }
2633 if(*sp==-1)sp++;
2634 else
2635 {
2636 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2637 RTjpeg_idct(bp+j+8, RTjpeg_block, RTjpeg_width);
2638 }
2639 if(*sp==-1)sp++;
2640 else
2641 {
2642 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
2643 RTjpeg_idct(bp2+k, RTjpeg_block, RTjpeg_width>>1);
2644 }
2645 if(*sp==-1)sp++;
2646 else
2647 {
2648 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
2649 RTjpeg_idct(bp3+k, RTjpeg_block, RTjpeg_width>>1);
2650 }
2651 }
2652 bp+=RTjpeg_width<<3;
2653 bp2+=RTjpeg_width<<2;
2654 bp3+=RTjpeg_width<<2;
2655 }
2656 #ifdef USE_MMX
2657 emms();
2658 #endif
2659 }
2660
2661 void RTjpeg_decompressYUV420(__s8 *sp, __u8 *bp)
2662 {
2663 register __s8 * bp1 = bp + (RTjpeg_width<<3);
2664 register __s8 * bp2 = bp + RTjpeg_Ysize;
2665 register __s8 * bp3 = bp2 + (RTjpeg_Csize>>1);
2666 int i, j,k;
2667
2668 #ifdef USE_MMX
2669 emms();
2670 #endif
2671
2672 /* Y */
2673 for(i=RTjpeg_height>>1; i; i-=8)
2674 {
2675 for(k=0, j=0; j<RTjpeg_width; j+=16, k+=8) {
2676 if(*sp==-1)sp++;
2677 else
2678 {
2679 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2680 RTjpeg_idct(bp+j, RTjpeg_block, RTjpeg_width);
2681 }
2682 if(*sp==-1)sp++;
2683 else
2684 {
2685 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2686 RTjpeg_idct(bp+j+8, RTjpeg_block, RTjpeg_width);
2687 }
2688 if(*sp==-1)sp++;
2689 else
2690 {
2691 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2692 RTjpeg_idct(bp1+j, RTjpeg_block, RTjpeg_width);
2693 }
2694 if(*sp==-1)sp++;
2695 else
2696 {
2697 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2698 RTjpeg_idct(bp1+j+8, RTjpeg_block, RTjpeg_width);
2699 }
2700 if(*sp==-1)sp++;
2701 else
2702 {
2703 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
2704 RTjpeg_idct(bp2+k, RTjpeg_block, RTjpeg_width>>1);
2705 }
2706 if(*sp==-1)sp++;
2707 else
2708 {
2709 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
2710 RTjpeg_idct(bp3+k, RTjpeg_block, RTjpeg_width>>1);
2711 }
2712 }
2713 bp+=RTjpeg_width<<4;
2714 bp1+=RTjpeg_width<<4;
2715 bp2+=RTjpeg_width<<2;
2716 bp3+=RTjpeg_width<<2;
2717 }
2718 #ifdef USE_MMX
2719 emms();
2720 #endif
2721 }
2722
2723 void RTjpeg_decompress8(__s8 *sp, __u8 *bp)
2724 {
2725 int i, j;
2726
2727 #ifdef USE_MMX
2728 emms();
2729 #endif
2730
2731 /* Y */
2732 for(i=0; i<RTjpeg_height; i+=8)
2733 {
2734 for(j=0; j<RTjpeg_width; j+=8)
2735 if(*sp==-1)sp++;
2736 else
2737 {
2738 sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
2739 RTjpeg_idct(bp+j, RTjpeg_block, RTjpeg_width);
2740 }
2741 bp+=RTjpeg_width<<3;
2742 }
2743 }
2744
2745 /*
2746 External Function
2747
2748 Initialise additional data structures for motion compensation
2749
2750 */
2751
2752 void RTjpeg_init_mcompress(void)
2753 {
2754 unsigned long tmp;
2755
2756 if(!RTjpeg_old)
2757 {
2758 RTjpeg_old=malloc((4*RTjpeg_width*RTjpeg_height)+32);
2759 tmp=(unsigned long)RTjpeg_old;
2760 tmp+=32;
2761 tmp=tmp>>5;
2762 RTjpeg_old=(__s16 *)(tmp<<5);
2763 }
2764 if (!RTjpeg_old)
2765 {
2766 fprintf(stderr, "RTjpeg: Could not allocate memory\n");
2767 exit(-1);
2768 }
2769 bzero(RTjpeg_old, ((4*RTjpeg_width*RTjpeg_height)));
2770 }
2771
2772 #ifdef USE_MMX
2773
2774 int RTjpeg_bcomp(__s16 *old, mmx_t *mask)
2775 {
2776 int i;
2777 mmx_t *mold=(mmx_t *)old;
2778 mmx_t *mblock=(mmx_t *)RTjpeg_block;
2779 mmx_t result;
2780 static mmx_t neg=(mmx_t)(unsigned long long)0xffffffffffffffffULL;
2781
2782 movq_m2r(*mask, mm7);
2783 movq_m2r(neg, mm6);
2784 pxor_r2r(mm5, mm5);
2785
2786 for(i=0; i<8; i++)
2787 {
2788 movq_m2r(*(mblock++), mm0);
2789 movq_m2r(*(mblock++), mm2);
2790 movq_m2r(*(mold++), mm1);
2791 movq_m2r(*(mold++), mm3);
2792 psubsw_r2r(mm1, mm0);
2793 psubsw_r2r(mm3, mm2);
2794 movq_r2r(mm0, mm1);
2795 movq_r2r(mm2, mm3);
2796 pcmpgtw_r2r(mm7, mm0);
2797 pcmpgtw_r2r(mm7, mm2);
2798 pxor_r2r(mm6, mm1);
2799 pxor_r2r(mm6, mm3);
2800 pcmpgtw_r2r(mm7, mm1);
2801 pcmpgtw_r2r(mm7, mm3);
2802 por_r2r(mm0, mm5);
2803 por_r2r(mm2, mm5);
2804 por_r2r(mm1, mm5);
2805 por_r2r(mm3, mm5);
2806 }
2807 movq_r2m(mm5, result);
2808
2809 if(result.q)
2810 {
2811 if(!RTjpeg_mtest)
2812 for(i=0; i<16; i++)((__u64 *)old)[i]=((__u64 *)RTjpeg_block)[i];
2813 return 0;
2814 }
2815 /* printf("."); */
2816 return 1;
2817 }
2818
2819 #else
2820 int RTjpeg_bcomp(__s16 *old, __u16 *mask)
2821 {
2822 int i;
2823
2824 for(i=0; i<64; i++)
2825 if(abs(old[i]-RTjpeg_block[i])>*mask)
2826 {
2827 if(!RTjpeg_mtest)
2828 for(i=0; i<16; i++)((__u64 *)old)[i]=((__u64 *)RTjpeg_block)[i];
2829 return 0;
2830 }
2831 return 1;
2832 }
2833 #endif
2834
2835 void RTjpeg_set_test(int i)
2836 {
2837 RTjpeg_mtest=i;
2838 }
2839
2840 int RTjpeg_mcompressYUV420(__s8 *sp, unsigned char *bp, __u16 lmask, __u16 cmask)
2841 {
2842 __s8 * sb;
2843 __s16 *block;
2844 register __s8 * bp1 = bp + (RTjpeg_width<<3);
2845 register __s8 * bp2 = bp + RTjpeg_Ysize;
2846 register __s8 * bp3 = bp2 + (RTjpeg_Csize>>1);
2847 register int i, j, k;
2848
2849 #ifdef USE_MMX
2850 emms();
2851 RTjpeg_lmask=(mmx_t)(((__u64)lmask<<48)|((__u64)lmask<<32)|((__u64)lmask<<16)|lmask);
2852 RTjpeg_cmask=(mmx_t)(((__u64)cmask<<48)|((__u64)cmask<<32)|((__u64)cmask<<16)|cmask);
2853 #else
2854 RTjpeg_lmask=lmask;
2855 RTjpeg_cmask=cmask;
2856 #endif
2857
2858 sb=sp;
2859 block=RTjpeg_old;
2860 /* Y */
2861 for(i=RTjpeg_height>>1; i; i-=8)
2862 {
2863 for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
2864 {
2865 RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
2866 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2867 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
2868 {
2869 *((__u8 *)sp++)=255;
2870 }
2871 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2872 block+=64;
2873
2874 RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
2875 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2876 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
2877 {
2878 *((__u8 *)sp++)=255;
2879 }
2880 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2881 block+=64;
2882
2883 RTjpeg_dctY(bp1+j, RTjpeg_block, RTjpeg_Ywidth);
2884 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2885 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
2886 {
2887 *((__u8 *)sp++)=255;
2888 }
2889 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2890 block+=64;
2891
2892 RTjpeg_dctY(bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
2893 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2894 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
2895 {
2896 *((__u8 *)sp++)=255;
2897 }
2898 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2899 block+=64;
2900
2901 RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
2902 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2903 if(RTjpeg_bcomp(block, &RTjpeg_cmask))
2904 {
2905 *((__u8 *)sp++)=255;
2906 }
2907 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2908 block+=64;
2909
2910 RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
2911 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2912 if(RTjpeg_bcomp(block, &RTjpeg_cmask))
2913 {
2914 *((__u8 *)sp++)=255;
2915 }
2916 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2917 block+=64;
2918 }
2919 bp+=RTjpeg_width<<4;
2920 bp1+=RTjpeg_width<<4;
2921 bp2+=RTjpeg_width<<2;
2922 bp3+=RTjpeg_width<<2;
2923
2924 }
2925 #ifdef USE_MMX
2926 emms();
2927 #endif
2928 return (sp-sb);
2929 }
2930
2931
2932 int RTjpeg_mcompressYUV422(__s8 *sp, unsigned char *bp, __u16 lmask, __u16 cmask)
2933 {
2934 __s8 * sb;
2935 __s16 *block;
2936 register __s8 * bp2;
2937 register __s8 * bp3;
2938 register int i, j, k;
2939
2940 #ifdef USE_MMX
2941 emms();
2942 RTjpeg_lmask=(mmx_t)(((__u64)lmask<<48)|((__u64)lmask<<32)|((__u64)lmask<<16)|lmask);
2943 RTjpeg_cmask=(mmx_t)(((__u64)cmask<<48)|((__u64)cmask<<32)|((__u64)cmask<<16)|cmask);
2944 #else
2945 RTjpeg_lmask=lmask;
2946 RTjpeg_cmask=cmask;
2947 #endif
2948
2949 bp = bp - RTjpeg_width*0;
2950 bp2 = bp + RTjpeg_Ysize-RTjpeg_width*0;
2951 bp3 = bp2 + RTjpeg_Csize;
2952
2953 sb=sp;
2954 block=RTjpeg_old;
2955 /* Y */
2956 for(i=RTjpeg_height; i; i-=8)
2957 {
2958 for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
2959 {
2960 RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
2961 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2962 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
2963 {
2964 *((__u8 *)sp++)=255;
2965 }
2966 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2967 block+=64;
2968
2969 RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
2970 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
2971 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
2972 {
2973 *((__u8 *)sp++)=255;
2974 }
2975 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
2976 block+=64;
2977
2978 RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
2979 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2980 if(RTjpeg_bcomp(block, &RTjpeg_cmask))
2981 {
2982 *((__u8 *)sp++)=255;
2983 }
2984 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2985 block+=64;
2986
2987 RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
2988 RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
2989 if(RTjpeg_bcomp(block, &RTjpeg_cmask))
2990 {
2991 *((__u8 *)sp++)=255;
2992 }
2993 else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
2994 block+=64;
2995
2996 }
2997 bp+=RTjpeg_width<<3;
2998 bp2+=RTjpeg_width<<2;
2999 bp3+=RTjpeg_width<<2;
3000 }
3001 printf ("%d\n", block - RTjpeg_old);
3002 #ifdef USE_MMX
3003 emms();
3004 #endif
3005 return (sp-sb);
3006 }
3007
3008 int RTjpeg_mcompress8(__s8 *sp, unsigned char *bp, __u16 lmask)
3009 {
3010 __s8 * sb;
3011 __s16 *block;
3012 int i, j;
3013
3014 #ifdef USE_MMX
3015 emms();
3016 RTjpeg_lmask=(mmx_t)(((__u64)lmask<<48)|((__u64)lmask<<32)|((__u64)lmask<<16)|lmask);
3017 #else
3018 RTjpeg_lmask=lmask;
3019 #endif
3020
3021
3022 sb=sp;
3023 block=RTjpeg_old;
3024 /* Y */
3025 for(i=0; i<RTjpeg_height; i+=8)
3026 {
3027 for(j=0; j<RTjpeg_width; j+=8)
3028 {
3029 RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_width);
3030 RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
3031 if(RTjpeg_bcomp(block, &RTjpeg_lmask))
3032 {
3033 *((__u8 *)sp++)=255;
3034 /* printf("* %d ", sp[-1]); */
3035 } else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
3036 block+=64;
3037 }
3038 bp+=RTjpeg_width<<3;
3039 }
3040 #ifdef USE_MMX
3041 emms();
3042 #endif
3043 return (sp-sb);
3044 }
3045
3046 void RTjpeg_color_init(void)
3047 {
3048 }
3049
3050 #define KcrR 76284
3051 #define KcrG 53281
3052 #define KcbG 25625
3053 #define KcbB 132252
3054 #define Ky 76284
3055
3056 void RTjpeg_yuv422rgb(__u8 *buf, __u8 *rgb, int stride)
3057 {
3058 int tmp;
3059 int i, j;
3060 __s32 y, crR, crG, cbG, cbB;
3061 __u8 *bufcr, *bufcb, *bufy, *bufoute;
3062 int yskip;
3063
3064 yskip=RTjpeg_width;
3065
3066 bufcb=&buf[RTjpeg_width*RTjpeg_height];
3067 bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/2];
3068 bufy=&buf[0];
3069 bufoute=rgb;
3070
3071 for(i=0; i<(RTjpeg_height); i++)
3072 {
3073 for(j=0; j<RTjpeg_width; j+=2)
3074 {
3075 crR=(*bufcr-128)*KcrR;
3076 crG=(*(bufcr++)-128)*KcrG;
3077 cbG=(*bufcb-128)*KcbG;
3078 cbB=(*(bufcb++)-128)*KcbB;
3079
3080 y=(bufy[j]-16)*Ky;
3081
3082 tmp=(y+crR)>>16;
3083 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3084 tmp=(y-crG-cbG)>>16;
3085 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3086 tmp=(y+cbB)>>16;
3087 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3088
3089 y=(bufy[j+1]-16)*Ky;
3090
3091 tmp=(y+crR)>>16;
3092 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3093 tmp=(y-crG-cbG)>>16;
3094 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3095 tmp=(y+cbB)>>16;
3096 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3097
3098 }
3099 bufy+=yskip;
3100 }
3101 }
3102
3103
3104 void RTjpeg_yuv420rgb(__u8 *buf, __u8 *rgb, int stride)
3105 {
3106 int tmp;
3107 int i, j;
3108 __s32 y, crR, crG, cbG, cbB;
3109 __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
3110 int oskip, yskip;
3111
3112 if(stride==0)
3113 oskip=RTjpeg_width*3;
3114 else
3115 oskip=2*stride-RTjpeg_width*3;
3116
3117 yskip=RTjpeg_width;
3118
3119 bufcb=&buf[RTjpeg_width*RTjpeg_height];
3120 bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/4];
3121 bufy=&buf[0];
3122 bufoute=rgb;
3123 bufouto=rgb+RTjpeg_width*3;
3124
3125 for(i=0; i<(RTjpeg_height>>1); i++)
3126 {
3127 for(j=0; j<RTjpeg_width; j+=2)
3128 {
3129 crR=(*bufcr-128)*KcrR;
3130 crG=(*(bufcr++)-128)*KcrG;
3131 cbG=(*bufcb-128)*KcbG;
3132 cbB=(*(bufcb++)-128)*KcbB;
3133
3134 y=(bufy[j]-16)*Ky;
3135
3136 tmp=(y+crR)>>16;
3137 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3138 tmp=(y-crG-cbG)>>16;
3139 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3140 tmp=(y+cbB)>>16;
3141 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3142
3143 y=(bufy[j+1]-16)*Ky;
3144
3145 tmp=(y+crR)>>16;
3146 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3147 tmp=(y-crG-cbG)>>16;
3148 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3149 tmp=(y+cbB)>>16;
3150 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3151
3152 y=(bufy[j+yskip]-16)*Ky;
3153
3154 tmp=(y+crR)>>16;
3155 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3156 tmp=(y-crG-cbG)>>16;
3157 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3158 tmp=(y+cbB)>>16;
3159 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3160
3161 y=(bufy[j+1+yskip]-16)*Ky;
3162
3163 tmp=(y+crR)>>16;
3164 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3165 tmp=(y-crG-cbG)>>16;
3166 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3167 tmp=(y+cbB)>>16;
3168 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3169
3170 }
3171 bufoute+=oskip;
3172 bufouto+=oskip;
3173 bufy+=yskip<<1;
3174 }
3175 }
3176
3177
3178 void RTjpeg_yuvrgb32(__u8 *buf, __u8 *rgb, int stride)
3179 {
3180 int tmp;
3181 int i, j;
3182 __s32 y, crR, crG, cbG, cbB;
3183 __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
3184 int oskip, yskip;
3185
3186 if(stride==0)
3187 oskip=RTjpeg_width*4;
3188 else
3189 oskip = 2*stride-RTjpeg_width*4;
3190 yskip=RTjpeg_width;
3191
3192 bufcb=&buf[RTjpeg_width*RTjpeg_height];
3193 bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/2];
3194 bufy=&buf[0];
3195 bufoute=rgb;
3196 bufouto=rgb+RTjpeg_width*4;
3197
3198 for(i=0; i<(RTjpeg_height>>1); i++)
3199 {
3200 for(j=0; j<RTjpeg_width; j+=2)
3201 {
3202 crR=(*bufcr-128)*KcrR;
3203 crG=(*(bufcr++)-128)*KcrG;
3204 cbG=(*bufcb-128)*KcbG;
3205 cbB=(*(bufcb++)-128)*KcbB;
3206
3207 y=(bufy[j]-16)*Ky;
3208
3209 tmp=(y+cbB)>>16;
3210 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3211 tmp=(y-crG-cbG)>>16;
3212 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3213 tmp=(y+crR)>>16;
3214 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3215 bufoute++;
3216
3217 y=(bufy[j+1]-16)*Ky;
3218
3219 tmp=(y+cbB)>>16;
3220 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3221 tmp=(y-crG-cbG)>>16;
3222 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3223 tmp=(y+crR)>>16;
3224 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3225 bufoute++;
3226
3227 y=(bufy[j+yskip]-16)*Ky;
3228
3229 tmp=(y+cbB)>>16;
3230 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3231 tmp=(y-crG-cbG)>>16;
3232 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3233 tmp=(y+crR)>>16;
3234 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3235 bufouto++;
3236
3237 y=(bufy[j+1+yskip]-16)*Ky;
3238
3239 tmp=(y+cbB)>>16;
3240 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3241 tmp=(y-crG-cbG)>>16;
3242 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3243 tmp=(y+crR)>>16;
3244 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3245 bufouto++;
3246
3247 }
3248 bufoute+=oskip;
3249 bufouto+=oskip;
3250 bufy+=yskip<<1;
3251 }
3252 }
3253
3254 void RTjpeg_yuvrgb24(__u8 *buf, __u8 *rgb, int stride)
3255 {
3256 int tmp;
3257 int i, j;
3258 __s32 y, crR, crG, cbG, cbB;
3259 __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
3260 int oskip, yskip;
3261
3262 if(stride==0)
3263 oskip=RTjpeg_width*3;
3264 else
3265 oskip=2*stride - RTjpeg_width*3;
3266
3267 yskip=RTjpeg_width;
3268
3269 bufcb=&buf[RTjpeg_width*RTjpeg_height];
3270 bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/4];
3271 bufy=&buf[0];
3272 bufoute=rgb;
3273 bufouto=rgb+RTjpeg_width*3;
3274
3275 for(i=0; i<(RTjpeg_height>>1); i++)
3276 {
3277 for(j=0; j<RTjpeg_width; j+=2)
3278 {
3279 crR=(*bufcr-128)*KcrR;
3280 crG=(*(bufcr++)-128)*KcrG;
3281 cbG=(*bufcb-128)*KcbG;
3282 cbB=(*(bufcb++)-128)*KcbB;
3283
3284 y=(bufy[j]-16)*Ky;
3285
3286 tmp=(y+cbB)>>16;
3287 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3288 tmp=(y-crG-cbG)>>16;
3289 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3290 tmp=(y+crR)>>16;
3291 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3292
3293 y=(bufy[j+1]-16)*Ky;
3294
3295 tmp=(y+cbB)>>16;
3296 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3297 tmp=(y-crG-cbG)>>16;
3298 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3299 tmp=(y+crR)>>16;
3300 *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
3301
3302 y=(bufy[j+yskip]-16)*Ky;
3303
3304 tmp=(y+cbB)>>16;
3305 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3306 tmp=(y-crG-cbG)>>16;
3307 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3308 tmp=(y+crR)>>16;
3309 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3310
3311 y=(bufy[j+1+yskip]-16)*Ky;
3312
3313 tmp=(y+cbB)>>16;
3314 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3315 tmp=(y-crG-cbG)>>16;
3316 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3317 tmp=(y+crR)>>16;
3318 *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
3319
3320 }
3321 bufoute+=oskip;
3322 bufouto+=oskip;
3323 bufy+=yskip<<1;
3324 }
3325 }
3326
3327 void RTjpeg_yuvrgb16(__u8 *buf, __u8 *rgb, int stride)
3328 {
3329 int tmp;
3330 int i, j;
3331 __s32 y, crR, crG, cbG, cbB;
3332 __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
3333 int oskip, yskip;
3334 unsigned char r, g, b;
3335
3336 if(stride==0)
3337 oskip=RTjpeg_width*2;
3338 else
3339 oskip=2*stride-RTjpeg_width*2;
3340
3341 yskip=RTjpeg_width;
3342
3343 bufcb=&buf[RTjpeg_width*RTjpeg_height];
3344 bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/4];
3345 bufy=&buf[0];
3346 bufoute=rgb;
3347 bufouto=rgb+RTjpeg_width*2;
3348
3349 for(i=0; i<(RTjpeg_height>>1); i++)
3350 {
3351 for(j=0; j<RTjpeg_width; j+=2)
3352 {
3353 crR=(*bufcr-128)*KcrR;
3354 crG=(*(bufcr++)-128)*KcrG;
3355 cbG=(*bufcb-128)*KcbG;
3356 cbB=(*(bufcb++)-128)*KcbB;
3357
3358 y=(bufy[j]-16)*Ky;
3359
3360 tmp=(y+cbB)>>16;
3361 b=(tmp>255)?255:((tmp<0)?0:tmp);
3362 tmp=(y-crG-cbG)>>16;
3363 g=(tmp>255)?255:((tmp<0)?0:tmp);
3364 tmp=(y+crR)>>16;
3365 r=(tmp>255)?255:((tmp<0)?0:tmp);
3366 tmp=(int)((int)b >> 3);
3367 tmp|=(int)(((int)g >> 2) << 5);
3368 tmp|=(int)(((int)r >> 3) << 11);
3369 *(bufoute++)=tmp&0xff;
3370 *(bufoute++)=tmp>>8;
3371
3372
3373 y=(bufy[j+1]-16)*Ky;
3374
3375 tmp=(y+cbB)>>16;
3376 b=(tmp>255)?255:((tmp<0)?0:tmp);
3377 tmp=(y-crG-cbG)>>16;
3378 g=(tmp>255)?255:((tmp<0)?0:tmp);
3379 tmp=(y+crR)>>16;
3380 r=(tmp>255)?255:((tmp<0)?0:tmp);
3381 tmp=(int)((int)b >> 3);
3382 tmp|=(int)(((int)g >> 2) << 5);
3383 tmp|=(int)(((int)r >> 3) << 11);
3384 *(bufoute++)=tmp&0xff;
3385 *(bufoute++)=tmp>>8;
3386
3387 y=(bufy[j+yskip]-16)*Ky;
3388
3389 tmp=(y+cbB)>>16;
3390 b=(tmp>255)?255:((tmp<0)?0:tmp);
3391 tmp=(y-crG-cbG)>>16;
3392 g=(tmp>255)?255:((tmp<0)?0:tmp);
3393 tmp=(y+crR)>>16;
3394 r=(tmp>255)?255:((tmp<0)?0:tmp);
3395 tmp=(int)((int)b >> 3);
3396 tmp|=(int)(((int)g >> 2) << 5);
3397 tmp|=(int)(((int)r >> 3) << 11);
3398 *(bufouto++)=tmp&0xff;
3399 *(bufouto++)=tmp>>8;
3400
3401 y=(bufy[j+1+yskip]-16)*Ky;
3402
3403 tmp=(y+cbB)>>16;
3404 b=(tmp>255)?255:((tmp<0)?0:tmp);
3405 tmp=(y-crG-cbG)>>16;
3406 g=(tmp>255)?255:((tmp<0)?0:tmp);
3407 tmp=(y+crR)>>16;
3408 r=(tmp>255)?255:((tmp<0)?0:tmp);
3409 tmp=(int)((int)b >> 3);
3410 tmp|=(int)(((int)g >> 2) << 5);
3411 tmp|=(int)(((int)r >> 3) << 11);
3412 *(bufouto++)=tmp&0xff;
3413 *(bufouto++)=tmp>>8;
3414
3415 }
3416 bufoute+=oskip;
3417 bufouto+=oskip;
3418 bufy+=yskip<<1;
3419 }
3420 }
3421
3422 /* fix stride */
3423
3424 void RTjpeg_yuvrgb8(__u8 *buf, __u8 *rgb, int stride)
3425 {
3426 bcopy(buf, rgb, RTjpeg_width*RTjpeg_height);
3427 }
3428
mob repository